@dallaylaen/ski-interpreter 2.3.2 → 2.4.0

package/lib/ski-interpreter.cjs.js

@@ -1,2244 +1,2139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/internal.js
-var require_internal = __commonJS({
-  "src/internal.js"(exports2, module2) {
-    var Tokenizer = class {
-      /**
-       * @desc Create a tokenizer that splits strings into tokens according to the given terms.
-       * The terms are interpreted as regular expressions, and are sorted by length
-       * to ensure that longer matches are preferred over shorter ones.
-       * @param {...string|RegExp} terms
-       */
-      constructor(...terms) {
-        const src = "$|(\\s+)|" + terms.map((s) => "(?:" + s + ")").sort((a, b) => b.length - a.length).join("|");
-        this.rex = new RegExp(src, "gys");
-      }
-      /**
-       * @desc Split the given string into tokens according to the terms specified in the constructor.
-       * @param {string} str
-       * @return {string[]}
-       */
-      split(str) {
-        this.rex.lastIndex = 0;
-        const list = [...str.matchAll(this.rex)];
-        const eol = list.pop();
-        const last = eol?.index ?? 0;
-        if (last !== str.length) {
-          throw new Error("Unknown tokens at pos " + last + "/" + str.length + " starting with " + str.substring(last));
-        }
-        return list.filter((x) => x[1] === void 0).map((x) => x[0]);
-      }
-    };
-    var tokRestrict = new Tokenizer("[-=+]", "[A-Z]", "\\b[a-z_][a-z_0-9]*\\b");
-    function restrict(set, spec) {
-      if (!spec)
-        return set;
-      let out = /* @__PURE__ */ new Set([...set]);
-      const act = {
-        "=": (sym) => {
-          out = /* @__PURE__ */ new Set([sym]);
-          mode = "+";
-        },
-        "+": (sym) => {
-          out.add(sym);
-        },
-        "-": (sym) => {
-          out.delete(sym);
-        }
-      };
-      let mode = "=";
-      for (const sym of tokRestrict.split(spec)) {
-        if (act[sym])
-          mode = sym;
-        else
-          act[mode](sym);
-      }
-      return out;
-    }
-    var TraverseControl = class {
-      /**
-       * @desc A wrapper for values returned by fold/traverse callbacks
-       *       which instructs the traversal to alter its behavior while
-       *       retaining the value in question.
-       *
-       *       This class is instantiated internally be `SKI.control.*` functions,
-       *       and is not intended to be used directly by client code.
-       *
-       * @template T
-       * @param {T} value
-       * @param {function(T): TraverseControl<T>} decoration
-       */
-      constructor(value, decoration) {
-        this.value = value;
-        this.decoration = decoration;
-      }
-    };
-    function unwrap(value) {
-      if (value instanceof TraverseControl)
-        return [value.value ?? void 0, value.decoration];
-      return [value ?? void 0, void 0];
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SKI: () => SKI
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/internal.ts
+var Tokenizer = class {
+  constructor(...terms) {
+    const src = "$|(\\s+)|" + terms.map((s) => "(?:" + s + ")").sort((a, b) => b.length - a.length).join("|");
+    this.rex = new RegExp(src, "gys");
+  }
+  /**
+   * @desc Split the given string into tokens according to the terms specified in the constructor.
+   * @param {string} str
+   * @return {string[]}
+   */
+  split(str) {
+    this.rex.lastIndex = 0;
+    const list = [...str.matchAll(this.rex)];
+    const eol = list.pop();
+    const last = eol?.index ?? 0;
+    if (last !== str.length) {
+      throw new Error("Unknown tokens at pos " + last + "/" + str.length + " starting with " + str.substring(last));
     }
-    function prepareWrapper(label) {
-      const fun = (value) => new TraverseControl(value, fun);
-      fun.label = label;
-      fun.toString = () => "TraverseControl::" + label;
-      return fun;
+    return list.filter((x) => x[1] === void 0).map((x) => x[0]);
+  }
+};
+var tokRestrict = new Tokenizer("[-=+]", "[A-Z]", "\\b[a-z_][a-z_0-9]*\\b");
+function restrict(set, spec) {
+  if (!spec)
+    return set;
+  let out = /* @__PURE__ */ new Set([...set]);
+  const act = {
+    "=": (sym) => {
+      out = /* @__PURE__ */ new Set([sym]);
+      mode = "+";
+    },
+    "+": (sym) => {
+      out.add(sym);
+    },
+    "-": (sym) => {
+      out.delete(sym);
     }
-    module2.exports = { Tokenizer, restrict, unwrap, prepareWrapper };
+  };
+  let mode = "=";
+  for (const sym of tokRestrict.split(spec)) {
+    if (act[sym])
+      mode = sym;
+    else
+      act[mode](sym);
   }
-});
+  return out;
+}
+var TraverseControl = class {
+  constructor(value, decoration) {
+    this.value = value;
+    this.decoration = decoration;
+  }
+};
+function unwrap(value) {
+  if (value instanceof TraverseControl)
+    return [value.value ?? void 0, value.decoration];
+  return [value ?? void 0, void 0];
+}
+function prepareWrapper(label) {
+  const fun = (value) => new TraverseControl(value, fun);
+  fun.label = label;
+  fun.toString = () => "TraverseControl::" + label;
+  return fun;
+}
 
-// src/expr.js
-var require_expr = __commonJS({
-  "src/expr.js"(exports2, module2) {
-    "use strict";
-    var { unwrap, prepareWrapper } = require_internal();
-    var DEFAULTS = {
-      max: 1e3,
-      maxArgs: 32
-    };
-    var ORDER = {
-      "leftmost-outermost": "LO",
-      "leftmost-innermost": "LI",
-      LO: "LO",
-      LI: "LI"
-    };
-    var control = {
-      descend: prepareWrapper("descend"),
-      prune: prepareWrapper("prune"),
-      redo: prepareWrapper("redo"),
-      stop: prepareWrapper("stop")
-    };
-    var native = {};
-    var Expr = class _Expr {
-      /**
-       *  @descr A combinatory logic expression.
-       *
-       *  Applications, variables, and other terms like combinators per se
-       *  are subclasses of this class.
-       *
-       *  @abstract
-       *  @property {{
-       *    scope?: any,
-       *    env?: { [key: string]: Expr },
-       *    src?: string,
-       *    parser: object,
-       *  }} [context]
-       * @property {number} [arity] - number of arguments the term is waiting for (if known)
-       * @property {string} [note] - a brief description what the term does
-       * @property {string} [fancyName] - how to display in html mode, e.g. &phi; instead of 'f'
-       *                Typically only applicable to descendants of Named.
-       * @property {TermInfo} [props] - properties inferred from the term's behavior
-       */
-      /**
-       *
-       * @desc Define properties of the term based on user supplied options and/or inference results.
-       *       Typically useful for declaring Native and Alias terms.
-       * @private
-       * @param {Object} options
-       * @param {string} [options.note] - a brief description what the term does
-       * @param {number} [options.arity] - number of arguments the term is waiting for (if known)
-       * @param {string} [options.fancy] - how to display in html mode, e.g. &phi; instead of 'f'
-       * @param {boolean} [options.canonize] - whether to try to infer the properties
-       * @param {number} [options.max] - maximum number of steps for inference, if canonize is true
-       * @param {number} [options.maxArgs] - maximum number of arguments for inference, if canonize is true
-       * @return {this}
-       */
-      _setup(options = {}) {
-        if (options.fancy !== void 0)
-          this.fancyName = options.fancyName;
-        if (options.note !== void 0)
-          this.note = options.note;
-        if (options.arity !== void 0)
-          this.arity = options.arity;
-        if (options.canonize) {
-          const guess = this.infer(options);
-          if (guess.normal) {
-            this.arity = this.arity ?? guess.arity;
-            this.note = this.note ?? guess.expr.format({ html: true, lambda: ["", " &mapsto; ", ""] });
-            delete guess.steps;
-            this.props = guess;
-          }
-        }
-        return this;
-      }
-      /**
-       * @desc apply self to zero or more terms and return the resulting term,
-       * without performing any calculations whatsoever
-       * @param {Expr} args
-       * @return {Expr}
-       */
-      apply(...args) {
-        let expr = this;
-        for (const arg of args)
-          expr = new App(expr, arg);
-        return expr;
-      }
-      /**
-       * @desc Replace all aliases in the expression with their definitions, recursively.
-       * @return {Expr}
-       */
-      expand() {
-        return this.traverse((e) => {
-          if (e instanceof Alias)
-            return e.impl.expand();
-        }) ?? this;
-      }
-      /**
-       * @desc Returns true if the expression contains only free variables and applications, false otherwise.
-       * @returns {boolean}
-       */
-      freeOnly() {
-        return !this.any((e) => !(e instanceof FreeVar || e instanceof App));
+// src/expr.ts
+var DEFAULTS = {
+  max: 1e3,
+  maxArgs: 32
+};
+var ORDER = {
+  "leftmost-outermost": "LO",
+  "leftmost-innermost": "LI",
+  LO: "LO",
+  LI: "LI"
+};
+var control = {
+  descend: prepareWrapper("descend"),
+  prune: prepareWrapper("prune"),
+  redo: prepareWrapper("redo"),
+  stop: prepareWrapper("stop")
+};
+var native = {};
+var Expr = class _Expr {
+  static {
+    this.control = control;
+  }
+  static {
+    this.native = native;
+  }
+  /**
+   *
+   * @desc Define properties of the term based on user supplied options and/or inference results.
+   *       Typically useful for declaring Native and Alias terms.
+   * @private
+   * @param {Object} options
+   * @param {string} [options.note] - a brief description what the term does
+   * @param {number} [options.arity] - number of arguments the term is waiting for (if known)
+   * @param {string} [options.fancy] - how to display in html mode, e.g. &phi; instead of 'f'
+   * @param {boolean} [options.canonize] - whether to try to infer the properties
+   * @param {number} [options.max] - maximum number of steps for inference, if canonize is true
+   * @param {number} [options.maxArgs] - maximum number of arguments for inference, if canonize is true
+   * @return {this}
+   */
+  _setup(options = {}) {
+    if (options.fancy !== void 0 && this instanceof Named)
+      this.fancyName = options.fancy;
+    if (options.note !== void 0)
+      this.note = options.note;
+    if (options.arity !== void 0)
+      this.arity = options.arity;
+    if (options.canonize) {
+      const guess = this.infer(options);
+      if (guess.normal) {
+        this.arity = this.arity ?? guess.arity;
+        this.note = this.note ?? guess.expr.format({ html: true, lambda: ["", " &mapsto; ", ""] });
+        delete guess.steps;
+        this.props = guess;
       }
-      /**
-       * @desc Traverse the expression tree, applying change() to each node.
-       *       If change() returns an Expr, the node is replaced with that value.
-       *       A null/undefined value is interpreted as
-       *       "descend further if applicable, or leave the node unchanged".
-       *
-       *       Returned values may be decorated:
-       *
-       *       SKI.control.prune will suppress further descending even if nothing was returned
-       *       SKI.control.stop will terminate further changes.
-       *       SKI.control.redo will apply the callback to the returned subtree, recursively.
-       *
-       *       Note that if redo was applied at least once to a subtree, a null return from the same subtree
-       *       will be replaced by the last non-null value returned.
-       *
-       *       The traversal order is leftmost-outermost, unless options.order = 'leftmost-innermost' is specified.
-       *       Short aliases 'LO' and 'LI' (case-sensitive) are also accepted.
-       *
-       *       Returns null if no changes were made, or the new expression otherwise.
-       *
-       * @param {{
-       *   order?: 'LO' | 'LI' | 'leftmost-outermost' | 'leftmost-innermost',
-       * }} [options]
-       * @param {(e:Expr) => TraverseValue<Expr>} change
-       * @returns {Expr|null}
-       */
-      traverse(options, change) {
-        if (typeof options === "function") {
-          change = options;
-          options = {};
+    }
+    return this;
+  }
+  /**
+   * @desc apply self to zero or more terms and return the resulting term,
+   * without performing any calculations whatsoever
+   * @param {Expr} args
+   * @return {Expr}
+   */
+  apply(...args) {
+    let expr = this;
+    for (const arg of args)
+      expr = new App(expr, arg);
+    return expr;
+  }
+  /**
+   * @desc Replace all aliases in the expression with their definitions, recursively.
+   * @return {Expr}
+   */
+  expand() {
+    return this.traverse((e) => {
+      if (e instanceof Alias)
+        return e.impl.expand();
+    }) ?? this;
+  }
+  /**
+   * @desc Traverse the expression tree, applying change() to each node.
+   *       If change() returns an Expr, the node is replaced with that value.
+   *       A null/undefined value is interpreted as
+   *       "descend further if applicable, or leave the node unchanged".
+   *
+   *       Returned values may be decorated:
+   *
+   *       SKI.control.prune will suppress further descending even if nothing was returned
+   *       SKI.control.stop will terminate further changes.
+   *       SKI.control.redo will apply the callback to the returned subtree, recursively.
+   *
+   *       Note that if redo was applied at least once to a subtree, a null return from the same subtree
+   *       will be replaced by the last non-null value returned.
+   *
+   *       The traversal order is leftmost-outermost, unless options.order = 'leftmost-innermost' is specified.
+   *       Short aliases 'LO' and 'LI' (case-sensitive) are also accepted.
+   *
+   *       Returns null if no changes were made, or the new expression otherwise.
+   *
+   * @param {{
+   *   order?: 'LO' | 'LI' | 'leftmost-outermost' | 'leftmost-innermost',
+   * }} [options]
+   * @param {(e:Expr) => TraverseValue<Expr>} change
+   * @returns {Expr|null}
+   */
+  traverse(options, change) {
+    if (typeof options === "function") {
+      change = options;
+      options = {};
+    }
+    const order = ORDER[options.order ?? "LO"];
+    if (order === void 0)
+      throw new Error("Unknown traversal order: " + options.order);
+    const [expr] = unwrap(this._traverse_redo({ order }, change));
+    return expr ?? null;
+  }
+  /**
+   * @private
+   * @param {Object} options
+   * @param {(e:Expr) => TraverseValue<Expr>} change
+   * @returns {TraverseValue<Expr>}
+   */
+  _traverse_redo(options, change) {
+    let action;
+    let expr = this;
+    let prev;
+    do {
+      prev = expr;
+      const next = options.order === "LI" ? expr._traverse_descend(options, change) ?? change(expr) : change(expr) ?? expr._traverse_descend(options, change);
+      [expr, action] = unwrap(next);
+    } while (expr && action === control.redo);
+    if (!expr && prev !== this)
+      expr = prev;
+    return action ? action(expr) : expr;
+  }
+  /**
+   * @private
+   * @param {Object} options
+   * @param {(e:Expr) => TraverseValue<Expr>} change
+   * @returns {TraverseValue<Expr>}
+   */
+  _traverse_descend(options, change) {
+    return null;
+  }
+  /**
+   * @desc Returns true if predicate() is true for any subterm of the expression, false otherwise.
+   *
+   * @param {(e: Expr) => boolean} predicate
+   * @returns {boolean}
+   */
+  any(predicate) {
+    return predicate(this);
+  }
+  /**
+   * @desc Fold the expression into a single value by recursively applying combine() to its subterms.
+   *       Nodes are traversed in leftmost-outermost order, i.e. the same order as reduction steps are taken.
+   *
+   * null or undefined return value from combine() means "keep current value and descend further".
+   *
+   * SKI.control provides primitives to control the folding flow:
+   *  - SKI.control.prune(value) means "use value and don't descend further into this branch";
+   *  - SKI.control.stop(value) means "stop folding immediately and return value".
+   *  - SKI.control.descend(value) is the default behavior, meaning "use value and descend further".
+   *
+   * This method is experimental and may change in the future.
+   *
+   * @experimental
+   * @template T
+   * @param {T} initial
+   * @param {(acc: T, expr: Expr) => TraverseValue<T>} combine
+   * @returns {T}
+   */
+  fold(initial, combine) {
+    const [value] = unwrap(this._fold(initial, combine));
+    return value ?? initial;
+  }
+  _fold(initial, combine) {
+    return combine(initial, this);
+  }
+  /**
+   * @experimental
+   * @desc  Fold an application tree bottom to top.
+   *        For each subtree, the function is given the term in the root position and
+   *        a list of the results of folding its arguments.
+   *
+   *        E.g. fold('x y (z t)', f) results in f(x, [f(y, []), f(z, [f(t, [])])])
+   *
+   * @example expr.foldBottomUp((head, tail) => {
+   *    if (head.arity && head.arity <= tail.length) {
+   *      return '(<span class="redex">'
+   *          + head + ' '
+   *          + tail.slice(0, head.arity).join(' ')
+   *          + '</span>'
+   *          + tail.slice(head.arity).join(' ')
+   *          + ')';
+   *    } else {
+   *       return '(' + head + ' ' + tail.join(' ') + ')';
+   *    }
+   * });
+   * @template T
+   * @param {(head: Expr, tail: T[]) => T} fun
+   * @return {T}
+   */
+  foldBottomUp(fun) {
+    const [head, ...tail] = this.unroll();
+    return fun(head, tail.map((e) => e.foldBottomUp(fun)));
+  }
+  /**
+   * @desc Try to empirically find an equivalent lambda term for the expression,
+   *       returning also the term's arity and some other properties.
+   *
+   *       This is used internally when declaring a Native / Alias term,
+   *       unless {canonize: false} is used.
+   *
+   *       As of current it only recognizes terms that have a normal form,
+   *       perhaps after adding some variables. This may change in the future.
+   *
+   *       Use toLambda() if you want to get a lambda term in any case.
+   *
+   * @param {{max?: number, maxArgs?: number}} options
+   * @return {TermInfo}
+   */
+  infer(options = {}) {
+    const skipNames = {};
+    this.traverse((e) => {
+      if (e instanceof Named)
+        skipNames[e.name] = true;
+      return void 0;
+    });
+    return this._infer({
+      max: options.max ?? DEFAULTS.max,
+      maxArgs: options.maxArgs ?? DEFAULTS.maxArgs,
+      skipNames
+    }, 0);
+  }
+  /**
+   * @desc Internal method for infer(), which performs the actual inference.
+   * @param {{max: number, maxArgs: number}} options
+   * @param {number} nargs - var index to avoid name clashes
+   * @returns {TermInfo}
+   * @private
+   */
+  _infer(options, nargs) {
+    const probe = [];
+    let steps = 0;
+    let expr = this;
+    main: for (let i = 0; i < options.maxArgs; i++) {
+      const next = expr.run({ max: options.max - steps });
+      steps += next.steps;
+      if (!next.final)
+        break;
+      if (firstVar(next.expr)) {
+        expr = next.expr;
+        if (!expr.any((e) => !(e instanceof FreeVar || e instanceof App)))
+          return maybeLambda(probe, expr, { steps });
+        const list = expr.unroll();
+        let discard = false;
+        let duplicate = false;
+        const acc = [];
+        for (let j = 1; j < list.length; j++) {
+          const sub = list[j]._infer(
+            { maxArgs: options.maxArgs - nargs, max: options.max - steps, skipNames: options.skipNames },
+            // limit recursion
+            nargs + i
+            // avoid variable name clashes
+          );
+          steps += sub.steps ?? 0;
+          if (!sub.expr)
+            break main;
+          if (sub.discard)
+            discard = true;
+          if (sub.duplicate)
+            duplicate = true;
+          acc.push(sub.expr);
         }
-        const order = ORDER[options.order ?? "LO"];
-        if (order === void 0)
-          throw new Error("Unknown traversal order: " + options.order);
-        const [expr, _] = unwrap(this._traverse_redo({ order }, change));
-        return expr;
-      }
-      /**
-       * @private
-       * @param {Object} options
-       * @param {(e:Expr) => TraverseValue<Expr>} change
-       * @returns {TraverseValue<Expr>}
-       */
-      _traverse_redo(options, change) {
-        let action;
-        let expr = this;
-        let prev;
-        do {
-          prev = expr;
-          const next = options.order === "LI" ? expr._traverse_descend(options, change) ?? change(expr) : change(expr) ?? expr._traverse_descend(options, change);
-          [expr, action] = unwrap(next);
-        } while (expr && action === control.redo);
-        if (!expr && prev !== this)
-          expr = prev;
-        return action ? action(expr) : expr;
+        return maybeLambda(probe, list[0].apply(...acc), { discard, duplicate, steps });
       }
-      /**
-       * @private
-       * @param {Object} options
-       * @param {(e:Expr) => TraverseValue<Expr>} change
-       * @returns {TraverseValue<Expr>}
-       */
-      _traverse_descend(options, change) {
+      while (options.skipNames[nthvar(nargs + i).name])
+        nargs++;
+      const push = nthvar(nargs + i);
+      probe.push(push);
+      expr = next.expr.apply(push);
+    }
+    return { normal: false, proper: false, steps };
+  }
+  /**
+   * @desc Expand an expression into a list of terms
+   * that give the initial expression when applied from left to right:
+   * ((a, b), (c, d)) => [a, b, (c, d)]
+   *
+   * This can be thought of as an opposite of apply:
+   * fun.apply(...arg).unroll() is exactly [fun, ...args]
+   * (even if ...arg is in fact empty).
+   *
+   * @returns {Expr[]}
+   */
+  unroll() {
+    return [this];
+  }
+  /**
+   * @desc Returns a series of lambda terms equivalent to the given expression,
+   *       up to the provided computation steps limit.
+   *
+   *       Unlike infer(), this method will always return something,
+   *       even if the expression has no normal form.
+   *
+   *       See also Expr.walk() and Expr.toSKI().
+   *
+   * @param {{
+   *   max?: number,
+   *   maxArgs?: number,
+   *   varGen?: function(void): FreeVar,
+   *   steps?: number,
+   *   html?: boolean,
+   *   latin?: number,
+   * }} options
+   * @return {IterableIterator<{expr: Expr, steps?: number, comment?: string}>}
+   */
+  *toLambda(options = {}) {
+    let expr = this.traverse((e) => {
+      if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)
         return null;
-      }
-      /**
-       * @desc Returns true if predicate() is true for any subterm of the expression, false otherwise.
-       *
-       * @param {(e: Expr) => boolean} predicate
-       * @returns {boolean}
-       */
-      any(predicate) {
-        return predicate(this);
-      }
-      /**
-       * @desc Fold the expression into a single value by recursively applying combine() to its subterms.
-       *       Nodes are traversed in leftmost-outermost order, i.e. the same order as reduction steps are taken.
-       *
-       * null or undefined return value from combine() means "keep current value and descend further".
-       *
-       * SKI.control provides primitives to control the folding flow:
-       *  - SKI.control.prune(value) means "use value and don't descend further into this branch";
-       *  - SKI.control.stop(value) means "stop folding immediately and return value".
-       *  - SKI.control.descend(value) is the default behavior, meaning "use value and descend further".
-       *
-       * This method is experimental and may change in the future.
-       *
-       * @experimental
-       * @template T
-       * @param {T} initial
-       * @param {(acc: T, expr: Expr) => TraverseValue<T>} combine
-       * @returns {T}
-       */
-      fold(initial, combine) {
-        const [value, _] = unwrap(this._fold(initial, combine));
-        return value ?? initial;
-      }
-      /**
-       * @template T
-       * @param {T} initial
-       * @param {(acc: T, expr: Expr) => TraverseValue<T>} combine
-       * @returns {TraverseValue<T>}
-       * @private
-       */
-      _fold(initial, combine) {
-        return combine(initial, this);
-      }
-      /**
-       * @desc rough estimate of the term's complexity
-       * @return {number}
-       */
-      weight() {
-        return 1;
-      }
-      /**
-       * @desc Try to empirically find an equivalent lambda term for the expression,
-       *       returning also the term's arity and some other properties.
-       *
-       *       This is used internally when declaring a Native / Alias term,
-       *       unless {canonize: false} is used.
-       *
-       *       As of current it only recognizes terms that have a normal form,
-       *       perhaps after adding some variables. This may change in the future.
-       *
-       *       Use toLambda() if you want to get a lambda term in any case.
-       *
-       * @param {{max?: number, maxArgs?: number}} options
-       * @return {TermInfo}
-       */
-      infer(options = {}) {
-        return this._infer({
-          max: options.max ?? DEFAULTS.max,
-          maxArgs: options.maxArgs ?? DEFAULTS.maxArgs
-        }, 0);
-      }
-      /**
-       * @desc Internal method for infer(), which performs the actual inference.
-       * @param {{max: number, maxArgs: number}} options
-       * @param {number} nargs - var index to avoid name clashes
-       * @returns {TermInfo}
-       * @private
-       */
-      _infer(options, nargs) {
-        const probe = [];
-        let steps = 0;
-        let expr = this;
-        main: for (let i = 0; i < options.maxArgs; i++) {
-          const next = expr.run({ max: options.max - steps });
-          steps += next.steps;
-          if (!next.final)
-            break;
-          if (firstVar(next.expr)) {
-            expr = next.expr;
-            if (!expr.any((e) => !(e instanceof FreeVar || e instanceof App)))
-              return maybeLambda(probe, expr, { steps });
-            const list = expr.unroll();
-            let discard = false;
-            let duplicate = false;
-            const acc = [];
-            for (let j = 1; j < list.length; j++) {
-              const sub = list[j]._infer(
-                { maxArgs: options.maxArgs - nargs, max: options.max - steps },
-                // limit recursion
-                nargs + i
-                // avoid variable name clashes
-              );
-              steps += sub.steps;
-              if (!sub.expr)
-                break main;
-              if (sub.discard)
-                discard = true;
-              if (sub.duplicate)
-                duplicate = true;
-              acc.push(sub.expr);
-            }
-            return maybeLambda(probe, list[0].apply(...acc), { discard, duplicate, steps });
-          }
-          const push = nthvar(nargs + i);
-          probe.push(push);
-          expr = next.expr.apply(push);
-        }
-        return { normal: false, proper: false, steps };
-      }
-      /**
-       * @desc Expand an expression into a list of terms
-       * that give the initial expression when applied from left to right:
-       * ((a, b), (c, d)) => [a, b, (c, d)]
-       *
-       * This can be thought of as an opposite of apply:
-       * fun.apply(...arg).unroll() is exactly [fun, ...args]
-       * (even if ...arg is in fact empty).
-       *
-       * @returns {Expr[]}
-       */
-      unroll() {
-        return [this];
-      }
-      /**
-       * @desc Returns a series of lambda terms equivalent to the given expression,
-       *       up to the provided computation steps limit,
-       *       in decreasing weight order.
-       *
-       *       Unlike infer(), this method will always return something,
-       *       even if the expression has no normal form.
-       *
-       *       See also Expr.walk() and Expr.toSKI().
-       *
-       * @param {{
-       *   max?: number,
-       *   maxArgs?: number,
-       *   varGen?: function(void): FreeVar,
-       *   steps?: number,
-       *   html?: boolean,
-       *   latin?: number,
-       * }} options
-       * @param {number} [maxWeight] - maximum allowed weight of terms in the sequence
-       * @return {IterableIterator<{expr: Expr, steps?: number, comment?: string}>}
-       */
-      *toLambda(options = {}) {
-        let expr = this.traverse((e) => {
-          if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)
-            return null;
+      const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });
+      if (!guess.normal)
+        throw new Error("Failed to infer an equivalent lambda term for " + e);
+      return guess.expr;
+    }) ?? this;
+    const seen = /* @__PURE__ */ new Set();
+    let steps = 0;
+    while (expr) {
+      const next = expr.traverse({ order: "LI" }, (e) => {
+        if (seen.has(e))
+          return null;
+        if (e instanceof App && e.fun instanceof Lambda) {
           const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });
-          if (!guess.normal)
-            throw new Error("Failed to infer an equivalent  lambda term for " + e);
-          return guess.expr;
-        }) ?? this;
-        const seen = /* @__PURE__ */ new Set();
-        let steps = 0;
-        while (expr) {
-          const next = expr.traverse({ order: "LI" }, (e) => {
-            if (seen.has(e))
-              return null;
-            if (e instanceof App && e.fun instanceof Lambda) {
-              const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });
-              steps += guess.steps;
-              if (!guess.normal) {
-                seen.add(e);
-                return null;
-              }
-              return control.stop(guess.expr);
-            }
-          });
-          yield { expr, steps };
-          expr = next;
-        }
-      }
-      /**
-       * @desc Rewrite the expression into S, K, and I combinators step by step.
-       *     Returns an iterator yielding the intermediate expressions,
-       *     along with the number of steps taken to reach them.
-       *
-       *     See also Expr.walk() and Expr.toLambda().
-       *
-       * @param {{max?: number}} [options]
-       * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}
-       */
-      *toSKI(options = {}) {
-        let expr = this.traverse((e) => {
-          if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)
+          steps += guess.steps ?? 0;
+          if (!guess.normal) {
+            seen.add(e);
             return null;
-          return e.infer().expr;
-        }) ?? this;
-        let steps = 0;
-        while (expr) {
-          const next = expr.traverse({ order: "LI" }, (e) => {
-            if (!(e instanceof Lambda) || e.impl instanceof Lambda)
-              return null;
-            if (e.impl === e.arg)
-              return control.stop(native.I);
-            if (!e.impl.any((t) => t === e.arg))
-              return control.stop(native.K.apply(e.impl));
-            if (!(e.impl instanceof App))
-              throw new Error("toSKI: assert failed: lambda body is of unexpected type " + e.impl.constructor.name);
-            if (e.impl.arg === e.arg && !e.impl.fun.any((t) => t === e.arg))
-              return control.stop(e.impl.fun);
-            return control.stop(native.S.apply(new Lambda(e.arg, e.impl.fun), new Lambda(e.arg, e.impl.arg)));
-          });
-          yield { expr, steps, final: !next };
-          steps++;
-          expr = next;
-        }
-      }
-      /**
-       * Replace all instances of plug in the expression with value and return the resulting expression,
-       * or null if no changes could be made.
-       * Lambda terms and applications will never match if used as plug
-       * as they are impossible co compare without extensive computations.
-       * Typically used on variables but can also be applied to other terms, e.g. aliases.
-       * See also Expr.traverse().
-       * @param {Expr} search
-       * @param {Expr} replace
-       * @return {Expr|null}
-       */
-      subst(search, replace) {
-        return this === search ? replace : null;
-      }
-      /**
-       * @desc Apply term reduction rules, if any, to the given argument.
-       * A returned value of null means no reduction is possible.
-       * A returned value of Expr means the reduction is complete and the application
-       *     of this and arg can be replaced with the result.
-       * A returned value of a function means that further arguments are needed,
-       *     and can be cached for when they arrive.
-       *
-       * This method is between apply() which merely glues terms together,
-       *     and step() which reduces the whole expression.
-       *
-       * foo.invoke(bar) is what happens inside foo.apply(bar).step() before
-       *     reduction of either foo or bar is attempted.
-       *
-       * The name 'invoke' was chosen to avoid confusion with either 'apply' or 'reduce'.
-       *
-       * @param {Expr} arg
-       * @returns {Partial | null}
-       */
-      invoke(arg) {
-        return null;
-      }
-      /**
-       * @desc iterate one step of a calculation.
-       * @return {{expr: Expr, steps: number, changed: boolean}}
-       */
-      step() {
-        return { expr: this, steps: 0, changed: false };
-      }
-      /**
-       * @desc Run uninterrupted sequence of step() applications
-       *       until the expression is irreducible, or max number of steps is reached.
-       *       Default number of steps = 1000.
-       * @param {{max?: number, steps?: number, throw?: boolean}|Expr} [opt]
-       * @param {Expr} args
-       * @return {{expr: Expr, steps: number, final: boolean}}
-       */
-      run(opt = {}, ...args) {
-        if (opt instanceof _Expr) {
-          args.unshift(opt);
-          opt = {};
-        }
-        let expr = args ? this.apply(...args) : this;
-        let steps = opt.steps ?? 0;
-        const max = Math.max(opt.max ?? DEFAULTS.max, 1) + steps;
-        let final = false;
-        for (; steps < max; ) {
-          const next = expr.step();
-          if (!next.changed) {
-            final = true;
-            break;
           }
-          steps += next.steps;
-          expr = next.expr;
-        }
-        if (opt.throw && !final)
-          throw new Error("Failed to compute expression in " + max + " steps");
-        return { final, steps, expr };
-      }
-      /**
-       * Execute step() while possible, yielding a brief description of events after each step.
-       * Mnemonics: like run() but slower.
-       * @param {{max?: number}} options
-       * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}
-       */
-      *walk(options = {}) {
-        const max = options.max ?? Infinity;
-        let steps = 0;
-        let expr = this;
-        let final = false;
-        while (steps < max) {
-          const next = expr.step();
-          if (!next.changed)
-            final = true;
-          yield { expr, steps, final };
-          if (final)
-            break;
-          steps += next.steps;
-          expr = next.expr;
-        }
-      }
-      /**
-       * @desc True is the expressions are identical, false otherwise.
-       *       Aliases are expanded.
-       *       Bound variables in lambda terms are renamed consistently.
-       *       However, no reductions are attempted.
-       *
-       *       E.g. a->b->a == x->y->x is true, but a->b->a == K is false.
-       *
-       * @param {Expr} other
-       * @return {boolean}
-       */
-      equals(other) {
-        return !this.diff(other);
-      }
-      /**
-       * @desc Recursively compare two expressions and return a string
-       *       describing the first point of difference.
-       *       Returns null if expressions are identical.
-       *
-       *       Aliases are expanded.
-       *       Bound variables in lambda terms are renamed consistently.
-       *       However, no reductions are attempted.
-       *
-       *       Members of the FreeVar class are considered different
-       *       even if they have the same name, unless they are the same object.
-       *       To somewhat alleviate confusion, the output will include
-       *       the internal id of the variable in square brackets.
-       *
-       * @example  "K(S != I)" is the result of comparing "KS" and "KI"
-       * @example  "S(K([x[13] != x[14]]))K"
-       *
-       * @param {Expr} other
-       * @param {boolean} [swap]  If true, the order of expressions is reversed in the output.
-       * @returns {string|null}
-       */
-      diff(other, swap = false) {
-        if (this === other)
-          return null;
-        if (other instanceof Alias)
-          return other.impl.diff(this, !swap);
-        return swap ? "[" + other + " != " + this + "]" : "[" + this + " != " + other + "]";
-      }
-      /**
-       * @desc Assert expression equality. Can be used in tests.
-       *
-       * `this` is the expected value and the argument is the actual one.
-       * Mnemonic: the expected value is always a combinator, the actual one may be anything.
-       *
-       * @param {Expr} actual
-       * @param {string} comment
-       */
-      expect(actual, comment = "") {
-        comment = comment ? comment + ": " : "";
-        if (!(actual instanceof _Expr)) {
-          throw new Error(comment + "Expected a combinator but found " + (actual?.constructor?.name ?? typeof actual));
-        }
-        const diff = this.diff(actual);
-        if (!diff)
-          return;
-        const poorMans = new Error(comment + diff);
-        poorMans.expected = this.diag();
-        poorMans.actual = actual.diag();
-        throw poorMans;
-      }
-      /**
-       * @desc Returns string representation of the expression.
-       *       Same as format() without options.
-       * @return {string}
-       */
-      toString() {
-        return this.format();
-      }
-      /**
-       * @desc Whether the expression needs parentheses when printed.
-       * @param {boolean} [first] - whether this is the first term in a sequence
-       * @return {boolean}
-       */
-      _braced(first) {
-        return false;
-      }
-      /**
-       * @desc Whether the expression can be printed without a space when followed by arg.
-       * @param {Expr} arg
-       * @returns {boolean}
-       * @private
-       */
-      _unspaced(arg) {
-        return this._braced(true);
-      }
-      /**
-       * @desc    Stringify the expression with fancy formatting options.
-       *          Said options mostly include wrappers around various constructs in form of ['(', ')'],
-       *          as well as terse and html flags that set up the defaults.
-       *          Format without options is equivalent to toString() and can be parsed back.
-       *
-       * @param   {Object} [options]  - formatting options
-       * @param   {boolean} [options.terse]   - whether to use terse formatting (omitting unnecessary spaces and parentheses)
-       * @param   {boolean} [options.html]    - whether to default to HTML tags & entities.
-       *                                If a named term has fancyName property set, it will be used instead of name in this mode.
-       * @param   {[string, string]} [options.brackets]  - wrappers for application arguments, typically ['(', ')']
-       * @param   {[string, string]} [options.var]       - wrappers for variable names
-       *                                (will default to &lt;var&gt; and &lt;/var&gt; in html mode).
-       * @param   {[string, string, string]} [options.lambda]    - wrappers for lambda abstractions, e.g. ['&lambda;', '.', '']
-       *                                where the middle string is placed between argument and body
-       *                                default is ['', '->', ''] or ['', '-&gt;', ''] for html
-       * @param   {[string, string]} [options.around]    - wrappers around (sub-)expressions.
-       *                                individual applications will not be wrapped, i.e. (a b c) but not ((a b) c)
-       * @param   {[string, string]} [options.redex]     - wrappers around the starting term(s) that have enough arguments to be reduced
-       * @param   {Object<string, Expr>} [options.inventory]     - if given, output aliases in the set as their names
-       *                                and any other aliases as the expansion of their definitions.
-       *                                The default is a cryptic and fragile mechanism dependent on a hidden mutable property.
-       * @returns {string}
-       *
-       * @example foo.format() // equivalent to foo.toString()
-       * @example foo.format({terse: false}) // spell out all parentheses
-       * @example foo.format({html: true}) // use HTML tags and entities
-       * @example foo.format({ around: ['(', ')'], brackets: ['', ''], lambda: ['(', '->', ')'] }) // lisp style, still back-parsable
-       * @exapmle foo.format({ lambda: ['&lambda;', '.', ''] }) // pretty-print for the math department
-       * @example foo.format({ lambda: ['', '=>', ''], terse: false }) // make it javascript
-       * @example foo.format({ inventory: { T } }) // use T as a named term, expand all others
-       *
-       */
-      format(options = {}) {
-        const fallback = options.html ? {
-          brackets: ["(", ")"],
-          space: " ",
-          var: ["<var>", "</var>"],
-          lambda: ["", "-&gt;", ""],
-          around: ["", ""],
-          redex: ["", ""]
-        } : {
-          brackets: ["(", ")"],
-          space: " ",
-          var: ["", ""],
-          lambda: ["", "->", ""],
-          around: ["", ""],
-          redex: ["", ""]
-        };
-        return this._format({
-          terse: options.terse ?? true,
-          brackets: options.brackets ?? fallback.brackets,
-          space: options.space ?? fallback.space,
-          var: options.var ?? fallback.var,
-          lambda: options.lambda ?? fallback.lambda,
-          around: options.around ?? fallback.around,
-          redex: options.redex ?? fallback.redex,
-          inventory: options.inventory,
-          // TODO better name
-          html: options.html ?? false
-        }, 0);
-      }
-      /**
-       * @desc Internal method for format(), which performs the actual formatting.
-       * @param {Object} options
-       * @param {number} nargs
-       * @returns {string}
-       * @private
-       */
-      _format(options, nargs) {
-        throw new Error("No _format() method defined in class " + this.constructor.name);
-      }
-      /**
-       * @desc Returns a string representation of the expression tree, with indentation to show structure.
-       *
-       *       Applications are flattened to avoid excessive nesting.
-       *       Variables include ids to distinguish different instances of the same variable name.
-       *
-       *       May be useful for debugging.
-       *
-       * @returns {string}
-       *
-       * @example
-       * > console.log(ski.parse('C 5 x (x->x x)').diag())
-       * App:
-       *   Native: C
-       *   Church: 5
-       *   FreeVar: x[53]
-       *   Lambda (x[54]):
-       *     App:
-       *       FreeVar: x[54]
-       *       FreeVar: x[54]
-       */
-      diag() {
-        const rec = (e, indent) => {
-          if (e instanceof App)
-            return [indent + "App:", ...e.unroll().flatMap((s) => rec(s, indent + "  "))];
-          if (e instanceof Lambda)
-            return [`${indent}Lambda (${e.arg}[${e.arg.id}]):`, ...rec(e.impl, indent + "  ")];
-          if (e instanceof Alias)
-            return [`${indent}Alias (${e.name}): \\`, ...rec(e.impl, indent)];
-          if (e instanceof FreeVar)
-            return [`${indent}FreeVar: ${e.name}[${e.id}]`];
-          return [`${indent}${e.constructor.name}: ${e}`];
-        };
-        const out = rec(this, "");
-        return out.join("\n");
-      }
-      /**
-       * @desc Convert the expression to a JSON-serializable format.
-       * @returns {string}
-       */
-      toJSON() {
-        return this.format();
-      }
-    };
-    var App = class _App extends Expr {
-      /**
-       * @desc Application of fun() to args.
-       * Never ever use new App(fun, arg) directly, use fun.apply(...args) instead.
-       * @param {Expr} fun
-       * @param {Expr} arg
-       */
-      constructor(fun, arg) {
-        super();
-        this.arg = arg;
-        this.fun = fun;
-      }
-      /** @property {boolean} [final] */
-      weight() {
-        return this.fun.weight() + this.arg.weight();
-      }
-      _traverse_descend(options, change) {
-        const [fun, fAction] = unwrap(this.fun._traverse_redo(options, change));
-        if (fAction === control.stop)
-          return control.stop(fun ? fun.apply(this.arg) : null);
-        const [arg, aAction] = unwrap(this.arg._traverse_redo(options, change));
-        const final = fun || arg ? (fun ?? this.fun).apply(arg ?? this.arg) : null;
-        if (aAction === control.stop)
-          return control.stop(final);
-        return final;
-      }
-      any(predicate) {
-        return predicate(this) || this.fun.any(predicate) || this.arg.any(predicate);
-      }
-      _fold(initial, combine) {
-        const [value = initial, action = "descend"] = unwrap(combine(initial, this));
-        if (action === control.prune)
-          return value;
-        if (action === control.stop)
-          return control.stop(value);
-        const [fValue = value, fAction = "descend"] = unwrap(this.fun._fold(value, combine));
-        if (fAction === control.stop)
-          return control.stop(fValue);
-        const [aValue = fValue, aAction = "descend"] = unwrap(this.arg._fold(fValue, combine));
-        if (aAction === control.stop)
-          return control.stop(aValue);
-        return aValue;
-      }
-      subst(search, replace) {
-        const fun = this.fun.subst(search, replace);
-        const arg = this.arg.subst(search, replace);
-        return fun || arg ? (fun ?? this.fun).apply(arg ?? this.arg) : null;
-      }
-      /**
-       * @return {{expr: Expr, steps: number}}
-       */
-      step() {
-        if (!this.final) {
-          const partial = this.fun.invoke(this.arg);
-          if (partial instanceof Expr)
-            return { expr: partial, steps: 1, changed: true };
-          else if (typeof partial === "function")
-            this.invoke = partial;
-          const fun = this.fun.step();
-          if (fun.changed)
-            return { expr: fun.expr.apply(this.arg), steps: fun.steps, changed: true };
-          const arg = this.arg.step();
-          if (arg.changed)
-            return { expr: this.fun.apply(arg.expr), steps: arg.steps, changed: true };
-          this.final = true;
-        }
-        return { expr: this, steps: 0, changed: false };
-      }
-      invoke(arg) {
-        const partial = this.fun.invoke(this.arg);
-        if (partial instanceof Expr)
-          return partial.apply(arg);
-        else if (typeof partial === "function") {
-          this.invoke = partial;
-          return partial(arg);
-        } else {
-          this.invoke = (_) => null;
-          return null;
+          return control.stop(guess.expr);
         }
-      }
-      unroll() {
-        return [...this.fun.unroll(), this.arg];
-      }
-      diff(other, swap = false) {
-        if (!(other instanceof _App))
-          return super.diff(other, swap);
-        const fun = this.fun.diff(other.fun, swap);
-        if (fun)
-          return fun + "(...)";
-        const arg = this.arg.diff(other.arg, swap);
-        if (arg)
-          return this.fun + "(" + arg + ")";
+      });
+      yield { expr, steps };
+      expr = next;
+    }
+  }
+  /**
+   * @desc Rewrite the expression into S, K, and I combinators step by step.
+   *     Returns an iterator yielding the intermediate expressions,
+   *     along with the number of steps taken to reach them.
+   *
+   *     See also Expr.walk() and Expr.toLambda().
+   *
+   * @param {{max?: number}} [options]
+   * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}
+   */
+  *toSKI(_options = {}) {
+    let expr = this.traverse((e) => {
+      if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)
         return null;
-      }
-      _braced(first) {
-        return !first;
-      }
-      _format(options, nargs) {
-        const fun = this.fun._format(options, nargs + 1);
-        const arg = this.arg._format(options, 0);
-        const wrap = nargs ? ["", ""] : options.around;
-        if (options.terse && !this.arg._braced(false))
-          return wrap[0] + fun + (this.fun._unspaced(this.arg) ? "" : options.space) + arg + wrap[1];
-        else
-          return wrap[0] + fun + options.brackets[0] + arg + options.brackets[1] + wrap[1];
-      }
-      _unspaced(arg) {
-        return this.arg._braced(false) ? true : this.arg._unspaced(arg);
-      }
-    };
-    var Named = class _Named extends Expr {
-      /**
-       * @desc An abstract class representing a term named 'name'.
-       *
-       * @param {String} name
-       */
-      constructor(name) {
-        super();
-        if (typeof name !== "string" || name.length === 0)
-          throw new Error("Attempt to create a named term with improper name");
-        this.name = name;
-      }
-      _unspaced(arg) {
-        return !!(arg instanceof _Named && (this.name.match(/^[A-Z+]$/) && arg.name.match(/^[a-z+]/i) || this.name.match(/^[a-z+]/i) && arg.name.match(/^[A-Z+]$/)));
-      }
-      _format(options, nargs) {
-        const name = options.html ? this.fancyName ?? this.name : this.name;
-        return this.arity > 0 && this.arity <= nargs ? options.redex[0] + name + options.redex[1] : name;
-      }
-    };
-    var freeId = 0;
-    var FreeVar = class _FreeVar extends Named {
-      /**
-       * @desc A named variable.
-       *
-       * Given the functional nature of combinatory logic, variables are treated
-       * as functions that we don't know how to evaluate just yet.
-       *
-       * By default, two different variables even with the same name are considered different.
-       * They display it via a hidden id property.
-       *
-       * If a scope object is given, however, two variables with the same name and scope
-       * are considered identical.
-       *
-       * By convention, FreeVar.global is a constant denoting a global unbound variable.
-       *
-       * @param {string} name - name of the variable
-       * @param {any} scope - an object representing where the variable belongs to.
-       */
-      constructor(name, scope) {
-        super(name);
-        this.id = ++freeId;
-        this.scope = scope === void 0 ? this : scope;
-      }
-      weight() {
-        return 0;
-      }
-      diff(other, swap = false) {
-        if (!(other instanceof _FreeVar))
-          return super.diff(other, swap);
-        if (this.name === other.name && this.scope === other.scope)
+      return e.infer().expr;
+    }) ?? this;
+    let steps = 0;
+    while (expr) {
+      const next = expr.traverse({ order: "LI" }, (e) => {
+        if (!(e instanceof Lambda) || e.impl instanceof Lambda)
           return null;
-        const lhs = this.name + "[" + this.id + "]";
-        const rhs = other.name + "[" + other.id + "]";
-        return swap ? "[" + rhs + " != " + lhs + "]" : "[" + lhs + " != " + rhs + "]";
-      }
-      subst(search, replace) {
-        if (search instanceof _FreeVar && search.name === this.name && search.scope === this.scope)
-          return replace;
-        return null;
-      }
-      _format(options, nargs) {
-        const name = options.html ? this.fancyName ?? this.name : this.name;
-        return options.var[0] + name + options.var[1];
-      }
+        if (e.impl === e.arg)
+          return control.stop(native.I);
+        if (!e.impl.any((t) => t === e.arg))
+          return control.stop(native.K.apply(e.impl));
+        if (!(e.impl instanceof App))
+          throw new Error("toSKI: assert failed: lambda body is of unexpected type " + e.impl.constructor.name);
+        if (e.impl.arg === e.arg && !e.impl.fun.any((t) => t === e.arg))
+          return control.stop(e.impl.fun);
+        return control.stop(native.S.apply(new Lambda(e.arg, e.impl.fun), new Lambda(e.arg, e.impl.arg)));
+      });
+      yield { expr, steps, final: !next };
+      steps++;
+      expr = next;
+    }
+  }
+  /**
+   * Replace all instances of plug in the expression with value and return the resulting expression,
+   * or null if no changes could be made.
+   * Lambda terms and applications will never match if used as plug
+   * as they are impossible co compare without extensive computations.
+   * Typically used on variables but can also be applied to other terms, e.g. aliases.
+   * See also Expr.traverse().
+   * @param {Expr} search
+   * @param {Expr} replace
+   * @return {Expr|null}
+   */
+  subst(search2, replace) {
+    return this === search2 ? replace : null;
+  }
+  /**
+   * @desc Apply term reduction rules, if any, to the given argument.
+   * A returned value of null means no reduction is possible.
+   * A returned value of Expr means the reduction is complete and the application
+   *     of this and arg can be replaced with the result.
+   * A returned value of a function means that further arguments are needed,
+   *     and can be cached for when they arrive.
+   *
+   * This method is between apply() which merely glues terms together,
+   *     and step() which reduces the whole expression.
+   *
+   * foo.invoke(bar) is what happens inside foo.apply(bar).step() before
+   *     reduction of either foo or bar is attempted.
+   *
+   * The name 'invoke' was chosen to avoid confusion with either 'apply' or 'reduce'.
+   *
+   * @param {Expr} arg
+   * @returns {Partial | null}
+   */
+  invoke(arg) {
+    return null;
+  }
+  /**
+   * @desc iterate one step of a calculation.
+   * @return {{expr: Expr, steps: number, changed: boolean}}
+   */
+  step() {
+    return { expr: this, steps: 0, changed: false };
+  }
+  /**
+   * @desc Run uninterrupted sequence of step() applications
+   *       until the expression is irreducible, or max number of steps is reached.
+   *       Default number of steps = 1000.
+   * @param {{max?: number, steps?: number, throw?: boolean}|Expr} [opt]
+   * @param {Expr} args
+   * @return {{expr: Expr, steps: number, final: boolean}}
+   */
+  run(opt = {}, ...args) {
+    if (opt instanceof _Expr) {
+      args.unshift(opt);
+      opt = {};
+    }
+    let expr = args ? this.apply(...args) : this;
+    let steps = opt.steps ?? 0;
+    const max = Math.max(opt.max ?? DEFAULTS.max, 1) + steps;
+    let final = false;
+    for (; steps < max; ) {
+      const next = expr.step();
+      if (!next.changed) {
+        final = true;
+        break;
+      }
+      steps += next.steps;
+      expr = next.expr;
+    }
+    if (opt.throw && !final)
+      throw new Error("Failed to compute expression in " + max + " steps");
+    return { final, steps, expr };
+  }
+  /**
+   * Execute step() while possible, yielding a brief description of events after each step.
+   * Mnemonics: like run() but slower.
+   * @param {{max?: number}} options
+   * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}
+   */
+  *walk(options = {}) {
+    const max = options.max ?? Infinity;
+    let steps = 0;
+    let expr = this;
+    let final = false;
+    while (steps < max) {
+      const next = expr.step();
+      if (!next.changed)
+        final = true;
+      yield { expr, steps, final };
+      if (final)
+        break;
+      steps += next.steps;
+      expr = next.expr;
+    }
+  }
+  /**
+   * @desc True is the expressions are identical, false otherwise.
+   *       Aliases are expanded.
+   *       Bound variables in lambda terms are renamed consistently.
+   *       However, no reductions are attempted.
+   *
+   *       E.g. a->b->a == x->y->x is true, but a->b->a == K is false.
+   *
+   * @param {Expr} other
+   * @return {boolean}
+   */
+  equals(other) {
+    return !this.diff(other);
+  }
+  /**
+   * @desc Recursively compare two expressions and return a string
+   *       describing the first point of difference.
+   *       Returns null if expressions are identical.
+   *
+   *       Aliases are expanded.
+   *       Bound variables in lambda terms are renamed consistently.
+   *       However, no reductions are attempted.
+   *
+   *       Members of the FreeVar class are considered different
+   *       even if they have the same name, unless they are the same object.
+   *       To somewhat alleviate confusion, the output will include
+   *       the internal id of the variable in square brackets.
+   *
+   * @example  "K(S != I)" is the result of comparing "KS" and "KI"
+   * @example  "S(K([x[13] != x[14]]))K"
+   *
+   * @param {Expr} other
+   * @param {boolean} [swap]  If true, the order of expressions is reversed in the output.
+   * @returns {string|null}
+   */
+  diff(other, swap = false) {
+    if (this === other)
+      return null;
+    if (other instanceof Alias)
+      return other.impl.diff(this, !swap);
+    return swap ? "[" + other + " != " + this + "]" : "[" + this + " != " + other + "]";
+  }
+  /**
+   * @desc Assert expression equality. Can be used in tests.
+   *
+   * `this` is the expected value and the argument is the actual one.
+   * Mnemonic: the expected value is always a combinator, the actual one may be anything.
+   *
+   * @param {Expr} actual
+   * @param {string} comment
+   */
+  expect(actual, comment = "") {
+    comment = comment ? comment + ": " : "";
+    if (!(actual instanceof _Expr)) {
+      throw new Error(comment + "Expected a combinator but found " + (actual?.constructor?.name ?? typeof actual));
+    }
+    const diff = this.diff(actual);
+    if (!diff)
+      return;
+    const poorMans = new Error(comment + diff);
+    poorMans.expected = this.diag();
+    poorMans.actual = actual.diag();
+    throw poorMans;
+  }
+  /**
+   * @desc Returns string representation of the expression.
+   *       Same as format() without options.
+   * @return {string}
+   */
+  toString() {
+    return this.format();
+  }
+  /**
+   * @desc Whether the expression needs parentheses when printed.
+   * @param {boolean} [first] - whether this is the first term in a sequence
+   * @return {boolean}
+   */
+  _braced(_first) {
+    return false;
+  }
+  /**
+   * @desc Whether the expression can be printed without a space when followed by arg.
+   * @param {Expr} arg
+   * @returns {boolean}
+   * @private
+   */
+  _unspaced(arg) {
+    return this._braced(true);
+  }
+  /**
+   * @desc    Stringify the expression with fancy formatting options.
+   *          Said options mostly include wrappers around various constructs in form of ['(', ')'],
+   *          as well as terse and html flags that set up the defaults.
+   *          Format without options is equivalent to toString() and can be parsed back.
+   *
+   * @param   {Object} [options]  - formatting options
+   * @param   {boolean} [options.terse]   - whether to use terse formatting (omitting unnecessary spaces and parentheses)
+   * @param   {boolean} [options.html]    - whether to default to HTML tags & entities.
+   *                                If a named term has fancyName property set, it will be used instead of name in this mode.
+   * @param   {[string, string]} [options.brackets]  - wrappers for application arguments, typically ['(', ')']
+   * @param   {[string, string]} [options.var]       - wrappers for variable names
+   *                                (will default to &lt;var&gt; and &lt;/var&gt; in html mode).
+   * @param   {[string, string, string]} [options.lambda]    - wrappers for lambda abstractions, e.g. ['&lambda;', '.', '']
+   *                                where the middle string is placed between argument and body
+   *                                default is ['', '->', ''] or ['', '-&gt;', ''] for html
+   * @param   {[string, string]} [options.around]    - wrappers around (sub-)expressions.
+   *                                individual applications will not be wrapped, i.e. (a b c) but not ((a b) c)
+   * @param   {[string, string]} [options.redex]     - wrappers around the starting term(s) that have enough arguments to be reduced
+   * @param   {Object<string, Expr>} [options.inventory]     - if given, output aliases in the set as their names
+   *                                and any other aliases as the expansion of their definitions.
+   *                                The default is a cryptic and fragile mechanism dependent on a hidden mutable property.
+   * @returns {string}
+   *
+   * @example foo.format() // equivalent to foo.toString()
+   * @example foo.format({terse: false}) // spell out all parentheses
+   * @example foo.format({html: true}) // use HTML tags and entities
+   * @example foo.format({ around: ['(', ')'], brackets: ['', ''], lambda: ['(', '->', ')'] }) // lisp style, still back-parsable
+   * @exapmle foo.format({ lambda: ['&lambda;', '.', ''] }) // pretty-print for the math department
+   * @example foo.format({ lambda: ['', '=>', ''], terse: false }) // make it javascript
+   * @example foo.format({ inventory: { T } }) // use T as a named term, expand all others
+   *
+   */
+  format(options = {}) {
+    const fallback = options.html ? {
+      brackets: ["(", ")"],
+      space: " ",
+      var: ["<var>", "</var>"],
+      lambda: ["", "-&gt;", ""],
+      around: ["", ""],
+      redex: ["", ""]
+    } : {
+      brackets: ["(", ")"],
+      space: " ",
+      var: ["", ""],
+      lambda: ["", "->", ""],
+      around: ["", ""],
+      redex: ["", ""]
     };
-    FreeVar.global = ["global"];
-    var Native = class extends Named {
-      /**
-       * @desc A named term with a known rewriting rule.
-       *       'impl' is a function with signature Expr => Expr => ... => Expr
-       *       (see typedef Partial).
-       *       This is how S, K, I, and company are implemented.
-       *
-       *       Note that as of current something like a=>b=>b(a) is not possible,
-       *       use full form instead: a=>b=>b.apply(a).
-       *
-       * @example new Native('K', x => y => x); // constant
-       * @example new Native('Y', function(f) { return f.apply(this.apply(f)); }); // self-application
-       *
-       * @param {String} name
-       * @param {Partial} impl
-       * @param {{note?: string, arity?: number, canonize?: boolean }} [opt]
-       */
-      constructor(name, impl, opt = {}) {
-        super(name);
-        this.invoke = impl;
-        this._setup({ canonize: true, ...opt });
-      }
+    return this._format({
+      terse: options.terse ?? true,
+      brackets: options.brackets ?? fallback.brackets,
+      space: options.space ?? fallback.space,
+      var: options.var ?? fallback.var,
+      lambda: options.lambda ?? fallback.lambda,
+      around: options.around ?? fallback.around,
+      redex: options.redex ?? fallback.redex,
+      inventory: options.inventory,
+      // TODO better name
+      html: options.html ?? false
+    }, 0);
+  }
+  /**
+   * @desc Internal method for format(), which performs the actual formatting.
+   * @param {Object} options
+   * @param {number} nargs
+   * @returns {string}
+   * @private
+   */
+  _format(options, nargs) {
+    throw new Error("No _format() method defined in class " + this.constructor.name);
+  }
+  /**
+   * @desc Returns a string representation of the expression tree, with indentation to show structure.
+   *
+   *       Applications are flattened to avoid excessive nesting.
+   *       Variables include ids to distinguish different instances of the same variable name.
+   *
+   *       May be useful for debugging.
+   *
+   * @returns {string}
+   *
+   * @example
+   * > console.log(ski.parse('C 5 x (x->x x)').diag())
+   * App:
+   *   Native: C
+   *   Church: 5
+   *   FreeVar: x[53]
+   *   Lambda (x[54]):
+   *     App:
+   *       FreeVar: x[54]
+   *       FreeVar: x[54]
+   */
+  diag() {
+    const rec = (e, indent) => {
+      if (e instanceof App)
+        return [indent + "App:", ...e.unroll().flatMap((s) => rec(s, indent + "  "))];
+      if (e instanceof Lambda)
+        return [`${indent}Lambda (${e.arg}[${e.arg.id}]):`, ...rec(e.impl, indent + "  ")];
+      if (e instanceof Alias)
+        return [`${indent}Alias (${e.name}): \\`, ...rec(e.impl, indent)];
+      if (e instanceof FreeVar)
+        return [`${indent}FreeVar: ${e.name}[${e.id}]`];
+      return [`${indent}${e.constructor.name}: ${e}`];
     };
-    var Lambda = class _Lambda extends Expr {
-      /**
-       * @desc Lambda abstraction of arg over impl.
-       *     Upon evaluation, all occurrences of 'arg' within 'impl' will be replaced
-       *     with the provided argument.
-       *
-       * Note that 'arg' will be replaced by a localized placeholder, so the original
-       * variable can be used elsewhere without interference.
-       * Listing symbols contained in the lambda will omit such placeholder.
-       *
-       * Legacy ([FreeVar], impl) constructor is supported but deprecated.
-       * It will create a nested lambda expression.
-       *
-       * @param {FreeVar} arg
-       * @param {Expr} impl
-       */
-      constructor(arg, impl) {
-        if (Array.isArray(arg)) {
-          if (arg.length === 0)
-            throw new Error("empty argument list in lambda constructor");
-          const [my, ...tail] = arg;
-          const known = /* @__PURE__ */ new Set([my.name]);
-          while (tail.length > 0) {
-            const last = tail.pop();
-            if (known.has(last.name))
-              throw new Error("Duplicate free var name " + last + " in lambda expression");
-            known.add(last.name);
-            impl = new _Lambda(last, impl);
-          }
-          arg = my;
-        }
-        super();
-        const local = new FreeVar(arg.name, this);
-        this.arg = local;
-        this.impl = impl.subst(arg, local) ?? impl;
-        this.arity = 1;
-      }
-      weight() {
-        return this.impl.weight() + 1;
-      }
-      invoke(arg) {
-        return this.impl.subst(this.arg, arg) ?? this.impl;
-      }
-      _traverse_descend(options, change) {
-        const [impl, iAction] = unwrap(this.impl._traverse_redo(options, change));
-        const final = impl ? new _Lambda(this.arg, impl) : null;
-        return iAction === control.stop ? control.stop(final) : final;
-      }
-      any(predicate) {
-        return predicate(this) || this.impl.any(predicate);
-      }
-      _fold(initial, combine) {
-        const [value = initial, action = "descend"] = unwrap(combine(initial, this));
-        if (action === control.prune)
-          return value;
-        if (action === control.stop)
-          return control.stop(value);
-        const [iValue, iAction] = unwrap(this.impl._fold(value, combine));
-        if (iAction === control.stop)
-          return control.stop(iValue);
-        return iValue ?? value;
-      }
-      subst(search, replace) {
-        if (search === this.arg)
-          return null;
-        const change = this.impl.subst(search, replace);
-        return change ? new _Lambda(this.arg, change) : null;
-      }
-      diff(other, swap = false) {
-        if (!(other instanceof _Lambda))
-          return super.diff(other, swap);
-        const t = new FreeVar("t");
-        const diff = this.invoke(t).diff(other.invoke(t), swap);
-        if (diff)
-          return "(t->" + diff + ")";
-        return null;
-      }
-      _format(options, nargs) {
-        return (nargs > 0 ? options.brackets[0] : "") + options.lambda[0] + this.arg._format(options, 0) + options.lambda[1] + this.impl._format(options, 0) + options.lambda[2] + (nargs > 0 ? options.brackets[1] : "");
-      }
-      _braced(first) {
-        return true;
-      }
+    const out = rec(this, "");
+    return out.join("\n");
+  }
+  /**
+   * @desc Convert the expression to a JSON-serializable format.
+   * @returns {string}
+   */
+  toJSON() {
+    return this.format();
+  }
+};
+var App = class _App extends Expr {
+  constructor(fun, arg) {
+    super();
+    this.arg = arg;
+    this.fun = fun;
+  }
+  /** @property {boolean} [final] */
+  _traverse_descend(options, change) {
+    const [fun, fAction] = unwrap(this.fun._traverse_redo(options, change));
+    if (fAction === control.stop)
+      return control.stop(fun ? fun.apply(this.arg) : null);
+    const [arg, aAction] = unwrap(this.arg._traverse_redo(options, change));
+    const final = fun || arg ? (fun ?? this.fun).apply(arg ?? this.arg) : null;
+    if (aAction === control.stop)
+      return control.stop(final);
+    return final;
+  }
+  any(predicate) {
+    return predicate(this) || this.fun.any(predicate) || this.arg.any(predicate);
+  }
+  _fold(initial, combine) {
+    const [value = initial, action = "descend"] = unwrap(combine(initial, this));
+    if (action === control.prune)
+      return value;
+    if (action === control.stop)
+      return control.stop(value);
+    const [fValue = value, fAction = "descend"] = unwrap(this.fun._fold(value, combine));
+    if (fAction === control.stop)
+      return control.stop(fValue);
+    const [aValue = fValue, aAction = "descend"] = unwrap(this.arg._fold(fValue, combine));
+    if (aAction === control.stop)
+      return control.stop(aValue);
+    return aValue;
+  }
+  subst(search2, replace) {
+    const fun = this.fun.subst(search2, replace);
+    const arg = this.arg.subst(search2, replace);
+    return fun || arg ? (fun ?? this.fun).apply(arg ?? this.arg) : null;
+  }
+  /**
+   * @return {{expr: Expr, steps: number}}
+   */
+  step() {
+    if (!this.final) {
+      const partial = this.fun.invoke(this.arg);
+      if (partial instanceof Expr)
+        return { expr: partial, steps: 1, changed: true };
+      else if (typeof partial === "function")
+        this.invoke = partial;
+      const fun = this.fun.step();
+      if (fun.changed)
+        return { expr: fun.expr.apply(this.arg), steps: fun.steps, changed: true };
+      const arg = this.arg.step();
+      if (arg.changed)
+        return { expr: this.fun.apply(arg.expr), steps: arg.steps, changed: true };
+      this.final = true;
+    }
+    return { expr: this, steps: 0, changed: false };
+  }
+  invoke(arg) {
+    const partial = this.fun.invoke(this.arg);
+    if (partial instanceof Expr)
+      return partial.apply(arg);
+    else if (typeof partial === "function") {
+      this.invoke = partial;
+      return partial(arg);
+    } else {
+      this.invoke = (arg2) => null;
+      return null;
+    }
+  }
+  unroll() {
+    return [...this.fun.unroll(), this.arg];
+  }
+  diff(other, swap = false) {
+    if (!(other instanceof _App))
+      return super.diff(other, swap);
+    const fun = this.fun.diff(other.fun, swap);
+    if (fun)
+      return fun + "(...)";
+    const arg = this.arg.diff(other.arg, swap);
+    if (arg)
+      return this.fun + "(" + arg + ")";
+    return null;
+  }
+  _braced(first) {
+    return !first;
+  }
+  _format(options, nargs) {
+    const fun = this.fun._format(options, nargs + 1);
+    const arg = this.arg._format(options, 0);
+    const wrap = nargs ? ["", ""] : options.around;
+    if (options.terse && !this.arg._braced(false))
+      return wrap[0] + fun + (this.fun._unspaced(this.arg) ? "" : options.space) + arg + wrap[1];
+    else
+      return wrap[0] + fun + options.brackets[0] + arg + options.brackets[1] + wrap[1];
+  }
+  _unspaced(arg) {
+    return this.arg._braced(false) ? true : this.arg._unspaced(arg);
+  }
+};
+var Named = class _Named extends Expr {
+  constructor(name) {
+    super();
+    if (typeof name !== "string" || name.length === 0)
+      throw new Error("Attempt to create a named term with improper name");
+    this.name = name;
+  }
+  _unspaced(arg) {
+    return !!(arg instanceof _Named && (this.name.match(/^[A-Z+]$/) && arg.name.match(/^[a-z+]/i) || this.name.match(/^[a-z+]/i) && arg.name.match(/^[A-Z+]$/)));
+  }
+  _format(options, nargs) {
+    const name = options.html ? this.fancyName ?? this.name : this.name;
+    return this.arity !== void 0 && this.arity > 0 && this.arity <= nargs ? options.redex[0] + name + options.redex[1] : name;
+  }
+};
+var freeId = 0;
+var FreeVar = class _FreeVar extends Named {
+  constructor(name, scope) {
+    super(name);
+    this.id = ++freeId;
+    this.scope = scope === void 0 ? this : scope;
+  }
+  diff(other, swap = false) {
+    if (!(other instanceof _FreeVar))
+      return super.diff(other, swap);
+    if (this.name === other.name && this.scope === other.scope)
+      return null;
+    const lhs = this.name + "[" + this.id + "]";
+    const rhs = other.name + "[" + other.id + "]";
+    return swap ? "[" + rhs + " != " + lhs + "]" : "[" + lhs + " != " + rhs + "]";
+  }
+  subst(search2, replace) {
+    if (search2 instanceof _FreeVar && search2.name === this.name && search2.scope === this.scope)
+      return replace;
+    return null;
+  }
+  _format(options, nargs) {
+    const name = options.html ? this.fancyName ?? this.name : this.name;
+    return options.var[0] + name + options.var[1];
+  }
+  static {
+    this.global = ["global"];
+  }
+};
+var Native = class extends Named {
+  /**
+   * @desc A named term with a known rewriting rule.
+   *       'impl' is a function with signature Expr => Expr => ... => Expr
+   *       (see typedef Partial).
+   *       This is how S, K, I, and company are implemented.
+   *
+   *       Note that as of current something like a=>b=>b(a) is not possible,
+   *       use full form instead: a=>b=>b.apply(a).
+   *
+   * @example new Native('K', x => y => x); // constant
+   * @example new Native('Y', function(f) { return f.apply(this.apply(f)); }); // self-application
+   *
+   * @param {String} name
+   * @param {Partial} impl
+   * @param {{note?: string, arity?: number, canonize?: boolean }} [opt]
+   */
+  constructor(name, impl, opt = {}) {
+    super(name);
+    this.invoke = impl;
+    this._setup({ canonize: true, ...opt });
+  }
+};
+var Lambda = class _Lambda extends Expr {
+  constructor(arg, impl) {
+    super();
+    if (!(arg instanceof FreeVar))
+      throw new Error("Lambda argument must be a FreeVar");
+    const local = new FreeVar(arg.name, this);
+    this.arg = local;
+    this.impl = impl.subst(arg, local) ?? impl;
+    this.arity = 1;
+  }
+  invoke(arg) {
+    return this.impl.subst(this.arg, arg) ?? this.impl;
+  }
+  _traverse_descend(options, change) {
+    const [impl, iAction] = unwrap(this.impl._traverse_redo(options, change));
+    const final = impl ? new _Lambda(this.arg, impl) : null;
+    return iAction === control.stop ? control.stop(final) : final;
+  }
+  any(predicate) {
+    return predicate(this) || this.impl.any(predicate);
+  }
+  _fold(initial, combine) {
+    const [value = initial, action = "descend"] = unwrap(combine(initial, this));
+    if (action === control.prune)
+      return value;
+    if (action === control.stop)
+      return control.stop(value);
+    const [iValue, iAction] = unwrap(this.impl._fold(value, combine));
+    if (iAction === control.stop)
+      return control.stop(iValue);
+    return iValue ?? value;
+  }
+  subst(search2, replace) {
+    if (search2 === this.arg)
+      return null;
+    const change = this.impl.subst(search2, replace);
+    return change ? new _Lambda(this.arg, change) : null;
+  }
+  diff(other, swap = false) {
+    if (!(other instanceof _Lambda))
+      return super.diff(other, swap);
+    const t = new FreeVar("t");
+    const diff = this.invoke(t).diff(other.invoke(t), swap);
+    if (diff)
+      return "(t->" + diff + ")";
+    return null;
+  }
+  _format(options, nargs) {
+    return (nargs > 0 ? options.brackets[0] : "") + options.lambda[0] + this.arg._format(options, 0) + options.lambda[1] + this.impl._format(options, 0) + options.lambda[2] + (nargs > 0 ? options.brackets[1] : "");
+  }
+  _braced(first) {
+    return true;
+  }
+};
+var Church = class _Church extends Expr {
+  constructor(n) {
+    n = Number.parseInt(String(n));
+    if (!(n >= 0))
+      throw new Error("Church number must be a non-negative integer");
+    super();
+    this.invoke = (x) => (y) => {
+      let expr = y;
+      for (let i = n; i-- > 0; )
+        expr = x.apply(expr);
+      return expr;
     };
-    var Church = class _Church extends Expr {
-      /**
-       * @desc Church numeral representing non-negative integer n:
-       *      n f x = f(f(...(f x)...)) with f applied n times.
-       * @param {number} n
-       */
-      constructor(n) {
-        n = Number.parseInt(n);
-        if (!(n >= 0))
-          throw new Error("Church number must be a non-negative integer");
-        super();
-        this.invoke = (x) => (y) => {
-          let expr = y;
-          for (let i = n; i-- > 0; )
-            expr = x.apply(expr);
-          return expr;
-        };
-        this.n = n;
-        this.arity = 2;
-      }
-      diff(other, swap = false) {
-        if (!(other instanceof _Church))
-          return super.diff(other, swap);
-        if (this.n === other.n)
-          return null;
-        return swap ? "[" + other.n + " != " + this.n + "]" : "[" + this.n + " != " + other.n + "]";
-      }
-      _unspaced(arg) {
-        return false;
-      }
-      _format(options, nargs) {
-        return nargs >= 2 ? options.redex[0] + this.n + options.redex[1] : this.n + "";
+    this.n = n;
+    this.arity = 2;
+  }
+  diff(other, swap = false) {
+    if (!(other instanceof _Church))
+      return super.diff(other, swap);
+    if (this.n === other.n)
+      return null;
+    return swap ? "[" + other.n + " != " + this.n + "]" : "[" + this.n + " != " + other.n + "]";
+  }
+  _unspaced(arg) {
+    return false;
+  }
+  _format(options, nargs) {
+    return nargs >= 2 ? options.redex[0] + this.n + options.redex[1] : this.n + "";
+  }
+};
+function waitn(expr, n) {
+  return (arg) => n <= 1 ? expr.apply(arg) : waitn(expr.apply(arg), n - 1);
+}
+var Alias = class extends Named {
+  constructor(name, impl, options = {}) {
+    super(name);
+    if (!(impl instanceof Expr))
+      throw new Error("Attempt to create an alias for a non-expression: " + impl);
+    this.impl = impl;
+    this._setup(options);
+    this.terminal = options.terminal ?? this.props?.proper;
+    this.invoke = waitn(impl, this.arity ?? 0);
+  }
+  /**
+   * @property {boolean} [outdated] - whether the alias is outdated
+   *     and should be replaced with its definition when encountered.
+   * @property {boolean} [terminal] - whether the alias should behave like a standalone term
+   *     // TODO better name?
+   * @property {boolean} [proper] - whether the alias is a proper combinator (i.e. contains no free variables or constants)
+   * @property {number} [arity] - the number of arguments the alias waits for before expanding
+   * @property {Expr} [canonical] - equivalent lambda term.
+   */
+  _traverse_descend(options, change) {
+    return this.impl._traverse_redo(options, change);
+  }
+  any(predicate) {
+    return predicate(this) || this.impl.any(predicate);
+  }
+  _fold(initial, combine) {
+    const [value = initial, action] = unwrap(combine(initial, this));
+    if (action === control.prune)
+      return value;
+    if (action === control.stop)
+      return control.stop(value);
+    const [iValue, iAction] = unwrap(this.impl._fold(value, combine));
+    if (iAction === control.stop)
+      return control.stop(iValue);
+    return iValue ?? value;
+  }
+  subst(search2, replace) {
+    if (this === search2)
+      return replace;
+    return this.impl.subst(search2, replace);
+  }
+  // DO NOT REMOVE TYPE or tsc chokes with
+  //       TS2527: The inferred type of 'Alias' references an inaccessible 'this' type.
+  /**
+   * @return {{expr: Expr, steps: number, changed: boolean}}
+   */
+  step() {
+    if ((this.arity ?? 0) > 0)
+      return { expr: this, steps: 0, changed: false };
+    return { expr: this.impl, steps: 0, changed: true };
+  }
+  diff(other, swap = false) {
+    if (this === other)
+      return null;
+    return other.diff(this.impl, !swap);
+  }
+  _braced(first) {
+    return this.outdated ? this.impl._braced(first) : false;
+  }
+  _format(options, nargs) {
+    const outdated = options.inventory ? options.inventory[this.name] !== this : this.outdated;
+    return outdated ? this.impl._format(options, nargs) : super._format(options, nargs);
+  }
+};
+function addNative(name, impl, opt = {}) {
+  native[name] = new Native(name, impl, opt);
+}
+addNative("I", (x) => x);
+addNative("K", (x) => (_y) => x);
+addNative("S", (x) => (y) => (z) => x.apply(z, y.apply(z)));
+addNative("B", (x) => (y) => (z) => x.apply(y.apply(z)));
+addNative("C", (x) => (y) => (z) => x.apply(z).apply(y));
+addNative("W", (x) => (y) => x.apply(y).apply(y));
+addNative(
+  "+",
+  (n) => n instanceof Church ? new Church(n.n + 1) : (f) => (x) => f.apply(n.apply(f, x)),
+  {
+    note: "Increase a Church numeral argument by 1, otherwise n => f => x => f(n f x)"
+  }
+);
+function firstVar(expr) {
+  while (expr instanceof App)
+    expr = expr.fun;
+  return expr instanceof FreeVar;
+}
+function maybeLambda(args, expr, caps) {
+  const count = new Array(args.length).fill(0);
+  let proper = true;
+  expr.traverse((e) => {
+    if (e instanceof FreeVar) {
+      const index = args.findIndex((a) => a.name === e.name);
+      if (index >= 0) {
+        count[index]++;
+        return;
       }
-    };
-    function waitn(expr, n) {
-      return (arg) => n <= 1 ? expr.apply(arg) : waitn(expr.apply(arg), n - 1);
     }
-    var Alias = class extends Named {
-      /**
-       * @desc A named alias for an existing expression.
-       *
-       *     Upon evaluation, the alias expands into the original expression,
-       *     unless it has a known arity > 0 and is marked terminal,
-       *     in which case it waits for enough arguments before expanding.
-       *
-       *     A hidden mutable property 'outdated' is used to silently
-       *     replace the alias with its definition in all contexts.
-       *     This is used when declaring named terms in an interpreter,
-       *     to avoid confusion between old and new terms with the same name.
-       *
-       * @param {String} name
-       * @param {Expr} impl
-       * @param {{canonize?: boolean, max?: number, maxArgs?: number, note?: string, terminal?: boolean}} [options]
-       */
-      constructor(name, impl, options = {}) {
-        super(name);
-        if (!(impl instanceof Expr))
-          throw new Error("Attempt to create an alias for a non-expression: " + impl);
-        this.impl = impl;
-        this._setup(options);
-        this.terminal = options.terminal ?? this.props?.proper;
-        this.invoke = waitn(impl, this.arity ?? 0);
-      }
-      /**
-       * @property {boolean} [outdated] - whether the alias is outdated
-       *     and should be replaced with its definition when encountered.
-       * @property {boolean} [terminal] - whether the alias should behave like a standalone term
-       *     // TODO better name?
-       * @property {boolean} [proper] - whether the alias is a proper combinator (i.e. contains no free variables or constants)
-       * @property {number} [arity] - the number of arguments the alias waits for before expanding
-       * @property {Expr} [canonical] - equivalent lambda term.
-       */
-      weight() {
-        return this.terminal ? 1 : this.impl.weight();
-      }
-      _traverse_descend(options, change) {
-        return this.impl._traverse_redo(options, change);
-      }
-      any(predicate) {
-        return predicate(this) || this.impl.any(predicate);
-      }
-      _fold(initial, combine) {
-        const [value = initial, action] = unwrap(combine(initial, this));
-        if (action === control.prune)
-          return value;
-        if (action === control.stop)
-          return control.stop(value);
-        const [iValue, iAction] = unwrap(this.impl._fold(value, combine));
-        if (iAction === control.stop)
-          return control.stop(iValue);
-        return iValue ?? value;
-      }
-      subst(search, replace) {
-        if (this === search)
-          return replace;
-        return this.impl.subst(search, replace);
-      }
-      // DO NOT REMOVE TYPE or tsc chokes with
-      //       TS2527: The inferred type of 'Alias' references an inaccessible 'this' type.
-      /**
-       * @return {{expr: Expr, steps: number, changed: boolean}}
-       */
-      step() {
-        if (this.arity > 0)
-          return { expr: this, steps: 0, changed: false };
-        return { expr: this.impl, steps: 0, changed: true };
-      }
-      diff(other, swap = false) {
-        if (this === other)
-          return null;
-        return other.diff(this.impl, !swap);
-      }
-      _braced(first) {
-        return this.outdated ? this.impl._braced(first) : false;
-      }
-      _format(options, nargs) {
-        const outdated = options.inventory ? options.inventory[this.name] !== this : this.outdated;
-        return outdated ? this.impl._format(options, nargs) : super._format(options, nargs);
-      }
-    };
-    function addNative(name, impl, opt) {
-      native[name] = new Native(name, impl, opt);
+    if (!(e instanceof App))
+      proper = false;
+    return void 0;
+  });
+  const skip = /* @__PURE__ */ new Set();
+  const dup = /* @__PURE__ */ new Set();
+  for (let i = 0; i < args.length; i++) {
+    if (count[i] === 0)
+      skip.add(i);
+    else if (count[i] > 1)
+      dup.add(i);
+  }
+  for (let i = args.length; i-- > 0; )
+    expr = new Lambda(args[i], expr);
+  return {
+    normal: true,
+    steps: caps.steps,
+    expr,
+    arity: args.length,
+    ...skip.size ? { skip } : {},
+    ...dup.size ? { dup } : {},
+    duplicate: !!dup.size || caps.duplicate || false,
+    discard: !!skip.size || caps.discard || false,
+    proper
+  };
+}
+function nthvar(n) {
+  return new FreeVar("abcdefgh"[n] ?? "x" + n);
+}
+var classes = { Expr, App, Named, FreeVar, Native, Lambda, Church, Alias };
+
+// src/toposort.ts
+function toposort(list, env) {
+  if (list instanceof Expr)
+    list = [list];
+  if (env) {
+    if (!list)
+      list = Object.keys(env).sort().map((k) => env[k]);
+  } else {
+    if (!list)
+      return { list: [], env: {} };
+    env = {};
+    for (const item of list) {
+      if (!(item instanceof Named))
+        continue;
+      if (env[item.name])
+        throw new Error("duplicate name " + item);
+      env[item.name] = item;
     }
-    addNative("I", (x) => x);
-    addNative("K", (x) => (_) => x);
-    addNative("S", (x) => (y) => (z) => x.apply(z, y.apply(z)));
-    addNative("B", (x) => (y) => (z) => x.apply(y.apply(z)));
-    addNative("C", (x) => (y) => (z) => x.apply(z).apply(y));
-    addNative("W", (x) => (y) => x.apply(y).apply(y));
-    addNative(
-      "+",
-      (n) => n instanceof Church ? new Church(n.n + 1) : (f) => (x) => f.apply(n.apply(f, x)),
-      {
-        note: "Increase a Church numeral argument by 1, otherwise n => f => x => f(n f x)"
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const rec = (term) => {
+    if (seen.has(term))
+      return;
+    term.fold(false, (acc, e) => {
+      if (e !== term && e instanceof Named && env[e.name] === e) {
+        rec(e);
+        return control.prune(false);
+      }
+    });
+    out.push(term);
+    seen.add(term);
+  };
+  for (const term of list)
+    rec(term);
+  return {
+    list: out,
+    env
+  };
+}
+
+// src/parser.ts
+var Empty = class extends Expr {
+  apply(...args) {
+    return args.length > 0 ? args.shift().apply(...args) : this;
+  }
+  postParse() {
+    throw new Error("Attempt to use empty expression () as a term");
+  }
+};
+var PartialLambda = class _PartialLambda extends Empty {
+  // TODO mutable! rewrite ro when have time
+  constructor(term, _known = {}) {
+    super();
+    this.impl = new Empty();
+    if (term instanceof FreeVar)
+      this.terms = [term];
+    else if (term instanceof _PartialLambda) {
+      if (!(term.impl instanceof FreeVar))
+        throw new Error("Expected FreeVar->...->FreeVar->Expr");
+      this.terms = [...term.terms, term.impl];
+    } else
+      throw new Error("Expected FreeVar or PartialLambda");
+  }
+  apply(term, ...tail) {
+    if (term === null || tail.length !== 0)
+      throw new Error("bad syntax in partial lambda expr");
+    this.impl = this.impl.apply(term);
+    return this;
+  }
+  postParse() {
+    let expr = this.impl;
+    for (let i = this.terms.length; i-- > 0; )
+      expr = new Lambda(this.terms[i], expr);
+    return expr;
+  }
+  // uncomment if debugging with prints
+  /* toString () {
+    return this.terms.join('->') + '->' + (this.impl ?? '???');
+  } */
+};
+function postParse(expr) {
+  return expr.postParse ? expr.postParse() : expr;
+}
+var combChars = new Tokenizer(
+  "[()]",
+  "[A-Z]",
+  "[a-z_][a-z_0-9]*",
+  "\\b[0-9]+\\b",
+  "->",
+  "\\+"
+);
+var Parser = class {
+  constructor(options = {}) {
+    this.annotate = !!options.annotate;
+    this.known = { ...native };
+    this.hasNumbers = true;
+    this.hasLambdas = true;
+    this.allow = new Set(Object.keys(this.known));
+    if (Array.isArray(options.terms))
+      this.bulkAdd(options.terms);
+    else if (options.terms) {
+      for (const name in options.terms) {
+        if (typeof options.terms[name] !== "string" || !options.terms[name].match(/^Native:/))
+          this.add(name, options.terms[name]);
       }
-    );
-    function firstVar(expr) {
-      while (expr instanceof App)
-        expr = expr.fun;
-      return expr instanceof FreeVar;
     }
-    function maybeLambda(args, expr, caps = {}) {
-      const count = new Array(args.length).fill(0);
-      let proper = true;
-      expr.traverse((e) => {
-        if (e instanceof FreeVar) {
-          const index = args.findIndex((a) => a.name === e.name);
-          if (index >= 0) {
-            count[index]++;
-            return;
-          }
-        }
-        if (!(e instanceof App))
-          proper = false;
-      });
-      const skip = /* @__PURE__ */ new Set();
-      const dup = /* @__PURE__ */ new Set();
-      for (let i = 0; i < args.length; i++) {
-        if (count[i] === 0)
-          skip.add(i);
-        else if (count[i] > 1)
-          dup.add(i);
-      }
-      return {
-        normal: true,
-        steps: caps.steps,
-        expr: args.length ? new Lambda(args, expr) : expr,
-        arity: args.length,
-        ...skip.size ? { skip } : {},
-        ...dup.size ? { dup } : {},
-        duplicate: !!dup.size || caps.duplicate || false,
-        discard: !!skip.size || caps.discard || false,
-        proper
-      };
+    this.hasNumbers = options.numbers ?? true;
+    this.hasLambdas = options.lambdas ?? true;
+    if (options.allow)
+      this.restrict(options.allow);
+  }
+  /**
+   * @desc Declare a new term
+   * If the first argument is an Alias, it is added as is.
+   * Otherwise, a new Alias or Native term (depending on impl type) is created.
+   * If note is not provided and this.annotate is true, an automatic note is generated.
+   *
+   * If impl is a function, it should have signature (Expr) => ... => Expr
+   * (see typedef Partial at top of expr.js)
+   *
+   * @example ski.add('T', 'S(K(SI))K', 'swap combinator')
+   * @example ski.add( ski.parse('T = S(K(SI))K') ) // ditto but one-arg form
+   * @example ski.add('T', x => y => y.apply(x), 'swap combinator') // heavy artillery
+   * @example ski.add('Y', function (f) { return f.apply(this.apply(f)); }, 'Y combinator')
+   *
+   * @param {Alias|String} term
+   * @param {String|Expr|function(Expr):Partial} [impl]
+   * @param {object|string} [options]
+   * @param {string} [options.note] - optional annotation for the term, default is auto-generated if this.annotate is true
+   * @param {boolean} [options.canonize] - whether to canonize the term's implementation, default is this.annotate
+   * @param {boolean} [options.fancy] - alternative HTML-friendly name for the term
+   * @param {number} [options.arity] - custom arity for the term, default is inferred from the implementation
+   * @return {SKI} chainable
+   */
+  add(term, impl, options) {
+    const named = this._named(term, impl);
+    const opts = typeof options === "string" ? { note: options, canonize: false } : options ?? {};
+    named._setup({ canonize: this.annotate, ...opts });
+    if (this.known[named.name])
+      this.known[named.name].outdated = true;
+    this.known[named.name] = named;
+    this.allow.add(named.name);
+    return this;
+  }
+  /**
+   * @desc Internal helper for add() that creates an Alias or Native term from the given arguments.
+   * @param {Alias|string} term
+   * @param {string|Expr|function(Expr):Partial} impl
+   * @returns {Native|Alias}
+   * @private
+   */
+  _named(term, impl) {
+    if (term instanceof Alias)
+      return new Alias(term.name, term.impl, { canonize: true });
+    if (typeof term !== "string")
+      throw new Error("add(): term must be an Alias or a string");
+    if (impl === void 0)
+      throw new Error("add(): impl must be provided when term is a string");
+    if (typeof impl === "string")
+      return new Alias(term, this.parse(impl), { canonize: true });
+    if (impl instanceof Expr)
+      return new Alias(term, impl, { canonize: true });
+    if (typeof impl === "function")
+      return new Native(term, impl);
+    throw new Error("add(): impl must be an Expr, a string, or a function with a signature Expr => ... => Expr");
+  }
+  /**
+   * @desc Declare a new term if it is not known, otherwise just allow it.
+   *       Currently only used by quests.
+   *       Use with caution, this function may change its signature, behavior, or even be removed in the future.
+   *
+   * @experimental
+   * @param {string|Alias} name
+   * @param {string|Expr|function(Expr):Partial} impl
+   * @returns {SKI}
+   */
+  maybeAdd(name, impl) {
+    if (this.known[name])
+      this.allow.add(name);
+    else
+      this.add(name, impl);
+    return this;
+  }
+  /**
+   * @desc Declare and remove multiple terms at once
+   *       term=impl adds term
+   *       term= removes term
+   * @param {string[]} list
+   * @return {SKI} chainable
+   */
+  bulkAdd(list) {
+    for (const item of list) {
+      const m = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\s*=\s*(.*)$/s);
+      if (!m)
+        throw new Error("bulkAdd: invalid declaration: " + item);
+      if (m[2] === "")
+        this.remove(m[1]);
+      else
+        this.add(m[1], this.parse(m[2]));
     }
-    function nthvar(n) {
-      return new FreeVar("abcdefgh"[n] ?? "x" + n);
+    return this;
+  }
+  /**
+   * Restrict the interpreter to given terms. Terms prepended with '+' will be added
+   * and terms preceeded with '-' will be removed.
+   * @example ski.restrict('SK') // use the basis
+   * @example ski.restrict('+I') // allow I now
+   * @example ski.restrict('-SKI +BCKW' ); // switch basis
+   * @example ski.restrict('-foo -bar'); // forbid some user functions
+   * @param {string} spec
+   * @return {SKI} chainable
+   */
+  restrict(spec) {
+    this.allow = restrict(this.allow, spec);
+    return this;
+  }
+  /**
+   *
+   * @param {string} spec
+   * @return {string}
+   */
+  showRestrict(spec = "+") {
+    const out = [];
+    let prevShort = true;
+    for (const term of [...restrict(this.allow, spec)].sort()) {
+      const nextShort = !!term.match(/^[A-Z]$/);
+      if (out.length && !(prevShort && nextShort))
+        out.push(" ");
+      out.push(term);
+      prevShort = nextShort;
     }
-    function toposort(list, env) {
-      if (list instanceof Expr)
-        list = [list];
-      if (env) {
-        if (!list)
-          list = Object.keys(env).sort().map((k) => env[k]);
-      } else {
-        if (!list)
-          return [];
-        if (!env) {
-          env = {};
-          for (const item of list) {
-            if (!(item instanceof Named))
-              continue;
-            if (env[item.name])
-              throw new Error("duplicate name " + item);
-            env[item.name] = item;
-          }
-        }
-      }
-      const out = [];
-      const seen = /* @__PURE__ */ new Set();
-      const rec = (term) => {
-        if (seen.has(term))
-          return;
-        term.fold(null, (acc, e) => {
-          if (e !== term && e instanceof Named && env[e.name] === e) {
-            rec(e);
-            return Expr.control.prune(null);
-          }
-        });
-        out.push(term);
-        seen.add(term);
-      };
-      for (const term of list)
-        rec(term);
-      return {
-        list: out,
-        env
-      };
+    return out.join("");
+  }
+  /**
+   *
+   * @param {String} name
+   * @return {SKI}
+   */
+  remove(name) {
+    this.known[name].outdated = true;
+    delete this.known[name];
+    this.allow.delete(name);
+    return this;
+  }
+  /**
+   *
+   * @return {{[key:string]: Native|Alias}}
+   */
+  getTerms() {
+    const out = {};
+    for (const name of Object.keys(this.known)) {
+      if (this.allow.has(name))
+        out[name] = this.known[name];
     }
-    Expr.native = native;
-    Expr.control = control;
-    Expr.extras = { toposort };
-    module2.exports = { Expr, App, Named, FreeVar, Lambda, Native, Alias, Church };
+    return out;
   }
-});
-
-// src/parser.js
-var require_parser = __commonJS({
-  "src/parser.js"(exports2, module2) {
-    "use strict";
-    var { Tokenizer, restrict } = require_internal();
-    var classes = require_expr();
-    var { Expr, Named, Native, Alias, FreeVar, Lambda, Church } = classes;
-    var { native } = Expr;
-    var Empty = class extends Expr {
-      apply(...args) {
-        return args.length ? args.shift().apply(...args) : this;
-      }
-      postParse() {
-        throw new Error("Attempt to use empty expression () as a term");
-      }
-    };
-    var PartialLambda = class _PartialLambda extends Empty {
-      // TODO mutable! rewrite ro when have time
-      constructor(term, known = {}) {
-        super();
-        this.impl = new Empty();
-        if (term instanceof FreeVar)
-          this.terms = [term];
-        else if (term instanceof _PartialLambda) {
-          if (!(term.impl instanceof FreeVar))
-            throw new Error("Expected FreeVar->...->FreeVar->Expr");
-          this.terms = [...term.terms, term.impl];
-        } else
-          throw new Error("Expected FreeVar or PartialLambda");
-      }
-      apply(term, ...tail) {
-        if (term === null || tail.length !== 0)
-          throw new Error("bad syntax in partial lambda expr");
-        this.impl = this.impl.apply(term);
-        return this;
-      }
-      postParse() {
-        return new Lambda(this.terms, this.impl);
+  /**
+   * @desc Export term declarations for use in bulkAdd().
+   * Currently only Alias terms are serialized.
+   * @returns {string[]}
+   */
+  declare() {
+    const env = {};
+    for (const [name, term] of Object.entries(this.getTerms())) {
+      if (term instanceof Alias)
+        env[name] = term;
+    }
+    const needDetour = {};
+    let i = 1;
+    for (const name in native) {
+      if (!(env[name] instanceof Alias))
+        continue;
+      while ("tmp" + i in env)
+        i++;
+      const temp = new Alias("tmp" + i, env[name]);
+      needDetour[temp.name] = env[name];
+      env[temp.name] = temp;
+      delete env[name];
+    }
+    const list = toposort(void 0, env).list;
+    const detour = /* @__PURE__ */ new Map();
+    if (Object.keys(needDetour).length) {
+      const rework = (expr) => {
+        return expr.traverse((e) => {
+          if (!(e instanceof Alias))
+            return null;
+          const newAlias = detour.get(e);
+          if (newAlias)
+            return newAlias;
+          return new Alias(e.name, rework(e.impl));
+        }) ?? expr;
+      };
+      for (let j = 0; j < list.length; j++) {
+        list[j] = rework(list[j]);
+        detour.set(needDetour[list[j].name], list[j]);
+        env[list[j].name] = list[j];
+        console.log(`list[${j}] = ${list[j].name}=${list[j].impl};`);
       }
-      // uncomment if debugging with prints
-      /* toString () {
-        return this.terms.join('->') + '->' + (this.impl ?? '???');
-      } */
-    };
-    function postParse(expr) {
-      return expr.postParse ? expr.postParse() : expr;
+      console.log("detour:", detour);
     }
-    var combChars = new Tokenizer(
-      "[()]",
-      "[A-Z]",
-      "[a-z_][a-z_0-9]*",
-      "\\b[0-9]+\\b",
-      "->",
-      "\\+"
+    const out = list.map(
+      (e) => needDetour[e.name] ? e.name + "=" + needDetour[e.name].name + "=" + e.impl.format({ inventory: env }) : e.name + "=" + e.impl.format({ inventory: env })
     );
-    var SKI2 = class {
-      /**
-       *
-       * @param {{
-       *    allow?: string,
-       *    numbers?: boolean,
-       *    lambdas?: boolean,
-       *    terms?: { [key: string]: Expr|string} | string[],
-       *    annotate?: boolean,
-       * }} [options]
-       */
-      constructor(options = {}) {
-        this.annotate = options.annotate ?? false;
-        this.known = { ...native };
-        this.hasNumbers = true;
-        this.hasLambdas = true;
-        this.allow = new Set(Object.keys(this.known));
-        if (Array.isArray(options.terms))
-          this.bulkAdd(options.terms);
-        else if (options.terms) {
-          for (const name in options.terms) {
-            if (!options.terms[name].match(/^Native:/))
-              this.add(name, options.terms[name]);
-          }
-        }
-        this.hasNumbers = options.numbers ?? true;
-        this.hasLambdas = options.lambdas ?? true;
-        if (options.allow)
-          this.restrict(options.allow);
-      }
-      /**
-       * @desc Declare a new term
-       * If the first argument is an Alias, it is added as is.
-       * Otherwise, a new Alias or Native term (depending on impl type) is created.
-       * If note is not provided and this.annotate is true, an automatic note is generated.
-       *
-       * If impl is a function, it should have signature (Expr) => ... => Expr
-       * (see typedef Partial at top of expr.js)
-       *
-       * @example ski.add('T', 'S(K(SI))K', 'swap combinator')
-       * @example ski.add( ski.parse('T = S(K(SI))K') ) // ditto but one-arg form
-       * @example ski.add('T', x => y => y.apply(x), 'swap combinator') // heavy artillery
-       * @example ski.add('Y', function (f) { return f.apply(this.apply(f)); }, 'Y combinator')
-       *
-       * @param {Alias|String} term
-       * @param {String|Expr|function(Expr):Partial} [impl]
-       * @param {object|string} [options]
-       * @param {string} [options.note] - optional annotation for the term, default is auto-generated if this.annotate is true
-       * @param {boolean} [options.canonize] - whether to canonize the term's implementation, default is this.annotate
-       * @param {boolean} [options.fancy] - alternative HTML-friendly name for the term
-       * @param {number} [options.arity] - custom arity for the term, default is inferred from the implementation
-       * @return {SKI} chainable
-       */
-      add(term, impl, options) {
-        term = this._named(term, impl);
-        if (typeof options === "string")
-          options = { note: options, canonize: false };
-        term._setup({ canonize: this.annotate, ...options });
-        if (this.known[term.name])
-          this.known[term.name].outdated = true;
-        this.known[term.name] = term;
-        this.allow.add(term.name);
-        return this;
-      }
-      /**
-       * @desc Internal helper for add() that creates an Alias or Native term from the given arguments.
-       * @param {Alias|string} term
-       * @param {string|Expr|function(Expr):Partial} impl
-       * @returns {Native|Alias}
-       * @private
-       */
-      _named(term, impl) {
-        if (term instanceof Alias)
-          return new Alias(term.name, term.impl, { canonize: true });
-        if (typeof term !== "string")
-          throw new Error("add(): term must be an Alias or a string");
-        if (impl === void 0)
-          throw new Error("add(): impl must be provided when term is a string");
-        if (typeof impl === "string")
-          return new Alias(term, this.parse(impl), { canonize: true });
-        if (impl instanceof Expr)
-          return new Alias(term, impl, { canonize: true });
-        if (typeof impl === "function")
-          return new Native(term, impl);
-        throw new Error("add(): impl must be an Expr, a string, or a function with a signature Expr => ... => Expr");
-      }
-      /**
-       * @desc Declare a new term if it is not known, otherwise just allow it.
-       *       Currently only used by quests.
-       *       Use with caution, this function may change its signature, behavior, or even be removed in the future.
-       *
-       * @experimental
-       * @param {string|Alias} name
-       * @param {string|Expr|function(Expr):Partial} impl
-       * @returns {SKI}
-       */
-      maybeAdd(name, impl) {
-        if (this.known[name])
-          this.allow.add(name);
-        else
-          this.add(name, impl);
-        return this;
-      }
-      /**
-       * @desc Declare and remove multiple terms at once
-       *       term=impl adds term
-       *       term= removes term
-       * @param {string[]} list
-       * @return {SKI} chainable
-       */
-      bulkAdd(list) {
-        for (const item of list) {
-          const m = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\s*=\s*(.*)$/s);
-          if (!m)
-            throw new Error("bulkAdd: invalid declaration: " + item);
-          if (m[2] === "")
-            this.remove(m[1]);
-          else
-            this.add(m[1], this.parse(m[2]));
-        }
-        return this;
-      }
-      /**
-       * Restrict the interpreter to given terms. Terms prepended with '+' will be added
-       * and terms preceeded with '-' will be removed.
-       * @example ski.restrict('SK') // use the basis
-       * @example ski.restrict('+I') // allow I now
-       * @example ski.restrict('-SKI +BCKW' ); // switch basis
-       * @example ski.restrict('-foo -bar'); // forbid some user functions
-       * @param {string} spec
-       * @return {SKI} chainable
-       */
-      restrict(spec) {
-        this.allow = restrict(this.allow, spec);
-        return this;
-      }
-      /**
-       *
-       * @param {string} spec
-       * @return {string}
-       */
-      showRestrict(spec = "+") {
-        const out = [];
-        let prevShort = true;
-        for (const term of [...restrict(this.allow, spec)].sort()) {
-          const nextShort = term.match(/^[A-Z]$/);
-          if (out.length && !(prevShort && nextShort))
-            out.push(" ");
-          out.push(term);
-          prevShort = nextShort;
-        }
-        return out.join("");
-      }
-      /**
-       *
-       * @param {String} name
-       * @return {SKI}
-       */
-      remove(name) {
-        this.known[name].outdated = true;
-        delete this.known[name];
-        this.allow.delete(name);
-        return this;
-      }
-      /**
-       *
-       * @return {{[key:string]: Native|Alias}}
-       */
-      getTerms() {
-        const out = {};
-        for (const name of Object.keys(this.known)) {
-          if (this.allow.has(name))
-            out[name] = this.known[name];
-        }
-        return out;
-      }
-      /**
-       * @desc Export term declarations for use in bulkAdd().
-       * Currently only Alias terms are serialized.
-       * @returns {string[]}
-       */
-      declare() {
-        const env = this.getTerms();
-        for (const name in env) {
-          if (!(env[name] instanceof Alias))
-            delete env[name];
-        }
-        const needDetour = {};
-        let i = 1;
-        for (const name in native) {
-          if (!(env[name] instanceof Alias))
-            continue;
-          while ("tmp" + i in env)
-            i++;
-          const temp = new Alias("tmp" + i, env[name]);
-          needDetour[temp] = env[name];
-          env[temp] = temp;
-          delete env[name];
-        }
-        const list = Expr.extras.toposort(void 0, env).list;
-        const detour = /* @__PURE__ */ new Map();
-        if (Object.keys(needDetour).length) {
-          const rework = (expr) => {
-            return expr.traverse((e) => {
-              if (!(e instanceof Alias))
-                return null;
-              const newAlias = detour.get(e);
-              if (newAlias)
-                return newAlias;
-              return new Alias(e.name, rework(e.impl));
-            }) ?? expr;
-          };
-          for (let i2 = 0; i2 < list.length; i2++) {
-            list[i2] = rework(list[i2], detour);
-            detour.set(needDetour[list[i2].name], list[i2]);
-            env[list[i2].name] = list[i2];
-            console.log(`list[${i2}] = ${list[i2].name}=${list[i2].impl};`);
-          }
-          console.log("detour:", detour);
-        }
-        const out = list.map(
-          (e) => needDetour[e] ? e.name + "=" + needDetour[e].name + "=" + e.impl.format({ inventory: env }) : e.name + "=" + e.impl.format({ inventory: env })
-        );
-        for (const [name, temp] of detour)
-          out.push(name + "=" + temp, temp + "=");
-        return out;
-      }
-      /**
-       * @template T
-       * @param {string} source
-       * @param {Object} [options]
-       * @param {{[keys: string]: Expr}} [options.env]
-       * @param {T} [options.scope]
-       * @param {boolean} [options.numbers]
-       * @param {boolean} [options.lambdas]
-       * @param {string} [options.allow]
-       * @return {Expr}
-       */
-      parse(source, options = {}) {
-        if (typeof source !== "string")
-          throw new Error("parse: source must be a string, got " + typeof source);
-        const lines = source.replace(/\/\/[^\n]*$/gm, " ").replace(/\/\*.*?\*\//gs, " ").trim().split(/\s*;[\s;]*/).filter((s) => s.match(/\S/));
-        const jar = { ...options.env };
-        let expr = new Empty();
-        for (const item of lines) {
-          if (expr instanceof Alias)
-            expr.outdated = true;
-          const def = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\s*=(.*)$/s);
-          if (def && def[2] === "")
-            expr = new FreeVar(def[1], options.scope ?? FreeVar.global);
-          else
-            expr = this.parseLine(item, jar, options);
-          if (def) {
-            if (jar[def[1]] !== void 0)
-              throw new Error("Attempt to redefine a known term: " + def[1]);
-            jar[def[1]] = expr;
-          }
-        }
-        expr.context = {
-          env: { ...this.getTerms(), ...jar },
-          // also contains pre-parsed terms
-          scope: options.scope,
-          src: source,
-          parser: this
-        };
-        return expr;
-      }
-      /**
-       * @desc Parse a single line of source code, without splitting it into declarations.
-       *       Internal, always use parse() instead.
-       * @template T
-       * @param {String} source S(KI)I
-       * @param {{[keys: string]: Expr}} env
-       * @param {Object} [options]
-       * @param {{[keys: string]: Expr}} [options.env] - unused, see 'env' argument
-       * @param {T} [options.scope]
-       * @param {boolean} [options.numbers]
-       * @param {boolean} [options.lambdas]
-       * @param {string} [options.allow]
-       * @return {Expr} parsed expression
-       */
-      parseLine(source, env = {}, options = {}) {
-        const aliased = source.match(/^\s*([A-Z]|[a-z][a-z_0-9]*)\s*=\s*(.*)$/s);
-        if (aliased)
-          return new Alias(aliased[1], this.parseLine(aliased[2], env, options));
-        const opt = {
-          numbers: options.numbers ?? this.hasNumbers,
-          lambdas: options.lambdas ?? this.hasLambdas,
-          allow: restrict(this.allow, options.allow)
-        };
-        opt.numbers ? opt.allow.add("+") : opt.allow.delete("+");
-        const tokens = combChars.split(source);
-        const empty = new Empty();
-        const stack = [empty];
-        const context = options.scope || FreeVar.global;
-        for (const c of tokens) {
-          if (c === "(")
-            stack.push(empty);
-          else if (c === ")") {
-            if (stack.length < 2)
-              throw new Error("unbalanced input: extra closing parenthesis" + source);
-            const x = postParse(stack.pop());
-            const f = stack.pop();
-            stack.push(f.apply(x));
-          } else if (c === "->") {
-            if (!opt.lambdas)
-              throw new Error("Lambdas not supported, allow them explicitly");
-            stack.push(new PartialLambda(stack.pop(), env));
-          } else if (c.match(/^[0-9]+$/)) {
-            if (!opt.numbers)
-              throw new Error("Church numbers not supported, allow them explicitly");
-            const f = stack.pop();
-            stack.push(f.apply(new Church(c)));
-          } else {
-            const f = stack.pop();
-            if (!env[c] && this.known[c] && !opt.allow.has(c)) {
-              throw new Error("Term '" + c + "' is not in the restricted set " + [...opt.allow].sort().join(" "));
-            }
-            const x = env[c] ?? this.known[c] ?? (env[c] = new FreeVar(c, context));
-            stack.push(f.apply(x));
-          }
-        }
-        if (stack.length !== 1) {
-          throw new Error("unbalanced input: missing " + (stack.length - 1) + " closing parenthesis:" + source);
-        }
-        return postParse(stack.pop());
-      }
-      toJSON() {
-        return {
-          version: "1.1.1",
-          // set to incremented package.json version whenever SKI serialization changes
-          allow: this.showRestrict("+"),
-          numbers: this.hasNumbers,
-          lambdas: this.hasLambdas,
-          annotate: this.annotate,
-          terms: this.declare()
-        };
-      }
-    };
-    SKI2.vars = function(scope = {}) {
-      const cache = {};
-      return new Proxy({}, {
-        get: (target, name) => {
-          if (!(name in cache))
-            cache[name] = new FreeVar(name, scope);
-          return cache[name];
-        }
-      });
-    };
-    SKI2.church = (n) => new Church(n);
-    for (const name in native)
-      SKI2[name] = native[name];
-    SKI2.classes = classes;
-    SKI2.native = native;
-    SKI2.control = Expr.control;
-    module2.exports = { SKI: SKI2 };
+    for (const [name, temp] of detour)
+      out.push(name.name + "=" + temp, temp + "=");
+    return out;
   }
-});
-
-// src/quest.js
-var require_quest = __commonJS({
-  "src/quest.js"(exports2, module2) {
-    var { SKI: SKI2 } = require_parser();
-    var { Expr, FreeVar, Alias, Lambda } = SKI2.classes;
-    var Quest2 = class {
-      /**
-       * @description A combinator problem with a set of test cases for the proposed solution.
-       * @param {QuestSpec} options
-       * @example const quest = new Quest({
-       *    input: 'identity',
-       *    cases: [
-       *      ['identity x', 'x'],
-       *    ],
-       *    allow: 'SK',
-       *    intro: 'Find a combinator that behaves like the identity function.',
-       * });
-       * quest.check('S K K'); // { pass: true, details: [...], ... }
-       * quest.check('K S');   // { pass: false, details: [...], ... }
-       * quest.check('K x');   // fail! internal variable x is not equal to free variable x,
-       *                       //     despite having the same name.
-       * quest.check('I');     // fail! I not in the allowed list.
-       */
-      constructor(options) {
-        const { input, cases, allow, numbers, lambdas, engine, engineFull, ...meta } = options;
-        const env = options.env ?? options.vars;
-        this.engine = engine ?? new SKI2();
-        this.engineFull = engineFull ?? new SKI2();
-        this.restrict = { allow, numbers: numbers ?? false, lambdas: lambdas ?? false };
-        this.env = {};
-        const jar = {};
-        for (const term of env ?? []) {
-          const expr = this.engineFull.parse(term, { env: jar, scope: this });
-          if (expr instanceof SKI2.classes.Alias)
-            this.env[expr.name] = new Alias(expr.name, expr.impl, { terminal: true, canonize: false });
-          else if (expr instanceof SKI2.classes.FreeVar)
-            this.env[expr.name] = expr;
-          else
-            throw new Error("Unsupported given variable type: " + term);
-        }
-        this.input = [];
-        for (const term of Array.isArray(input) ? input : [input])
-          this.addInput(term);
-        if (!this.input.length)
-          throw new Error("Quest needs at least one input placeholder");
-        this.envFull = { ...this.env, ...jar };
-        for (const term of this.input) {
-          if (term.name in this.envFull)
-            throw new Error("input placeholder name is duplicated or clashes with env: " + term.name);
-          this.envFull[term.name] = term.placeholder;
-        }
-        this.cases = [];
-        this.name = meta.name ?? meta.title;
-        meta.intro = list2str(meta.intro ?? meta.descr);
-        this.intro = meta.intro;
-        this.id = meta.id;
-        this.meta = meta;
-        for (const c of cases ?? [])
-          this.add(...c);
-      }
-      /**
-       *   Display allowed terms based on what engine thinks of this.env + this.restrict.allow
-       *   @return {string}
-       */
-      allowed() {
-        const allow = this.restrict.allow ?? "";
-        const env = Object.keys(this.env).sort();
-        return allow ? this.engine.showRestrict(allow + "+" + env.join(" ")) : env.map((s) => "+" + s).join(" ");
-      }
-      addInput(term) {
-        if (typeof term !== "object")
-          term = { name: term };
-        if (typeof term.name !== "string")
-          throw new Error("quest 'input' field must be a string or a {name: string, ...} object");
-        term.placeholder = new SKI2.classes.FreeVar(term.name);
-        this.input.push(term);
-      }
-      /**
-       *
-       * @param {{} | string} opt
-       * @param {string} terms
-       * @return {Quest}
-       */
-      add(opt, ...terms) {
-        if (typeof opt === "string") {
-          terms.unshift(opt);
-          opt = {};
-        } else
-          opt = { ...opt };
-        opt.engine = opt.engine ?? this.engineFull;
-        opt.env = opt.env ?? this.envFull;
-        const input = this.input.map((t) => t.placeholder);
-        this.cases.push(
-          opt.caps ? new PropertyCase(input, opt, terms) : new ExprCase(input, opt, terms)
-        );
-        return this;
-      }
-      /**
-       * @description Statefully parse a list of strings into expressions or fancy aliases thereof.
-       * @param {string[]} input
-       * @return {{terms: Expr[], weight: number}}
-       */
-      prepare(...input) {
-        if (input.length !== this.input.length)
-          throw new Error("Solutions provided " + input.length + " terms where " + this.input.length + " are expected");
-        let weight = 0;
-        const prepared = [];
-        const jar = { ...this.env };
-        for (let i = 0; i < input.length; i++) {
-          const spec = this.input[i];
-          const impl = this.engine.parse(input[i], {
-            env: jar,
-            allow: spec.allow ?? this.restrict.allow,
-            numbers: spec.numbers ?? this.restrict.numbers,
-            lambdas: spec.lambdas ?? this.restrict.lambdas
-          });
-          const arsenal = { ...this.engine.getTerms(), ...jar };
-          weight += impl.fold(0, (a, e) => {
-            if (e instanceof SKI2.classes.Named && arsenal[e.name] === e)
-              return SKI2.control.prune(a + 1);
-          });
-          const expr = impl instanceof FreeVar ? impl : new Alias(spec.fancy ?? spec.name, impl, { terminal: true, canonize: false });
-          jar[spec.name] = expr;
-          prepared.push(expr);
-        }
-        return {
-          prepared,
-          weight
-        };
-      }
-      /**
-       *
-       * @param {string} input
-       * @return {QuestResult}
-       */
-      check(...input) {
-        try {
-          const { prepared, weight } = this.prepare(...input);
-          const details = this.cases.map((c) => c.check(...prepared));
-          const pass = details.reduce((acc, val) => acc && val.pass, true);
-          const steps = details.reduce((acc, val) => acc + val.steps, 0);
-          return {
-            expr: prepared[0],
-            input: prepared,
-            pass,
-            steps,
-            details,
-            weight
-          };
-        } catch (e) {
-          return { pass: false, details: [], exception: e, steps: 0, input };
-        }
-      }
-      verify(options) {
-        const findings = this.verifyMeta(options);
-        if (options.solutions) {
-          const solCheck = this.verifySolutions(options.solutions);
-          if (solCheck)
-            findings.solutions = solCheck;
-        }
-        if (options.seen) {
-          if (!this.id)
-            findings.seen = "No id in quest " + (this.name ?? "(unnamed)");
-          if (options.seen.has(this.id))
-            findings.seen = "Duplicate quest id " + this.id;
-          options.seen.add(this.id);
-        }
-        return Object.keys(findings).length ? findings : null;
-      }
-      /**
-       * @desc Verify that solutions that are expected to pass/fail do so.
-       * @param {SelfCheck|{[key: string]: SelfCheck}} dataset
-       * @return {{shouldPass: {input: string[], result: QuestResult}[], shouldFail: {input: string[], result: QuestResult}[]} | null}
-       */
-      verifySolutions(dataset) {
-        if (typeof dataset === "object" && !Array.isArray(dataset?.accepted) && !Array.isArray(dataset?.rejected)) {
-          if (!this.id || !dataset[this.id])
-            return null;
-        }
-        const { accepted = [], rejected = [] } = dataset[this.id] ?? dataset;
-        const ret = { shouldPass: [], shouldFail: [] };
-        for (const input of accepted) {
-          const result = this.check(...input);
-          if (!result.pass)
-            ret.shouldPass.push({ input, result });
-        }
-        for (const input of rejected) {
-          const result = this.check(...input);
-          if (result.pass)
-            ret.shouldFail.push({ input, result });
-        }
-        return ret.shouldFail.length + ret.shouldPass.length ? ret : null;
-      }
-      verifyMeta(options = {}) {
-        const findings = {};
-        for (const field of ["name", "intro"]) {
-          const found = checkHtml(this[field]);
-          if (found)
-            findings[field] = found;
-        }
-        if (options.date) {
-          const date = new Date(this.meta.created_at);
-          if (isNaN(date))
-            findings.date = "invalid date format: " + this.meta.created_at;
-          else if (date < /* @__PURE__ */ new Date("2024-07-15") || date > /* @__PURE__ */ new Date())
-            findings.date = "date out of range: " + this.meta.created_at;
-        }
-        return findings;
-      }
-      /**
-         *
-         * @return {TestCase[]}
-         */
-      show() {
-        return [...this.cases];
-      }
-    };
-    var Case = class {
-      /**
-       * @param {FreeVar[]} input
-       * @param {{
-       *   max?: number,
-       *   note?: string,
-       *   env?: {[key:string]: Expr},
-       *   engine: SKI
-       * }} options
-       */
-      constructor(input, options) {
-        this.max = options.max ?? 1e3;
-        this.note = options.note;
-        this.env = { ...options.env ?? {} };
-        this.input = input;
-        this.engine = options.engine;
-      }
-      parse(src) {
-        return new Subst(this.engine.parse(src, { env: this.env, scope: this }), this.input);
-      }
-      /**
-       * @param {Expr} expr
-       * @return {CaseResult}
-       */
-      check(...expr) {
-        throw new Error("not implemented");
-      }
-    };
-    var ExprCase = class extends Case {
-      /**
-       * @param {FreeVar[]} input
-       * @param {{
-       *    max?: number,
-       *    note?: string,
-       *    env?: {string: Expr},
-       *    engine?: SKI
-       * }} options
-       * @param {[e1: string, e2: string]} terms
-       */
-      constructor(input, options, terms) {
-        if (terms.length !== 2)
-          throw new Error("Case accepts exactly 2 strings");
-        super(input, options);
-        [this.e1, this.e2] = terms.map((s) => this.parse(s));
-      }
-      check(...args) {
-        const e1 = this.e1.apply(args);
-        const r1 = e1.run({ max: this.max });
-        const e2 = this.e2.apply(args);
-        const r2 = e2.run({ max: this.max });
-        let reason = null;
-        if (!r1.final || !r2.final)
-          reason = "failed to reach normal form in " + this.max + " steps";
-        else
-          reason = r1.expr.diff(r2.expr);
-        return {
-          pass: !reason,
-          reason,
-          steps: r1.steps,
-          start: e1,
-          found: r1.expr,
-          expected: r2.expr,
-          note: this.note,
-          args,
-          case: this
-        };
+  /**
+   * @template T
+   * @param {string} source
+   * @param {Object} [options]
+   * @param {{[keys: string]: Expr}} [options.env]
+   * @param {T} [options.scope]
+   * @param {boolean} [options.numbers]
+   * @param {boolean} [options.lambdas]
+   * @param {string} [options.allow]
+   * @return {Expr}
+   */
+  parse(source, options = {}) {
+    if (typeof source !== "string")
+      throw new Error("parse: source must be a string, got " + typeof source);
+    const lines = source.replace(/\/\/[^\n]*$/gm, " ").replace(/\/\*.*?\*\//gs, " ").trim().split(/\s*;[\s;]*/).filter((s) => s.match(/\S/));
+    const jar = { ...options.env };
+    let expr = new Empty();
+    for (const item of lines) {
+      if (expr instanceof Alias)
+        expr.outdated = true;
+      const def = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\s*=(.*)$/s);
+      if (def && def[2] === "")
+        expr = new FreeVar(def[1], options.scope ?? FreeVar.global);
+      else
+        expr = this.parseLine(item, jar, options);
+      if (def) {
+        if (jar[def[1]] !== void 0)
+          throw new Error("Attempt to redefine a known term: " + def[1]);
+        jar[def[1]] = expr;
       }
+    }
+    expr.context = {
+      env: { ...this.getTerms(), ...jar },
+      // also contains pre-parsed terms
+      scope: options.scope,
+      src: source,
+      parser: this
     };
-    var knownCaps = {
-      normal: true,
-      proper: true,
-      discard: true,
-      duplicate: true,
-      linear: true,
-      affine: true,
-      arity: true
+    return expr;
+  }
+  /**
+   * @desc Parse a single line of source code, without splitting it into declarations.
+   *       Internal, always use parse() instead.
+   * @template T
+   * @param {String} source S(KI)I
+   * @param {{[keys: string]: Expr}} env
+   * @param {Object} [options]
+   * @param {{[keys: string]: Expr}} [options.env] - unused, see 'env' argument
+   * @param {T} [options.scope]
+   * @param {boolean} [options.numbers]
+   * @param {boolean} [options.lambdas]
+   * @param {string} [options.allow]
+   * @return {Expr} parsed expression
+   */
+  parseLine(source, env = {}, options = {}) {
+    const aliased = source.match(/^\s*([A-Z]|[a-z][a-z_0-9]*)\s*=\s*(.*)$/s);
+    if (aliased)
+      return new Alias(aliased[1], this.parseLine(aliased[2], env, options));
+    const opt = {
+      numbers: options.numbers ?? this.hasNumbers,
+      lambdas: options.lambdas ?? this.hasLambdas,
+      allow: restrict(this.allow, options.allow)
     };
-    var PropertyCase = class extends Case {
-      // test that an expression uses all of its inputs exactly once
-      constructor(input, options, terms) {
-        super(input, options);
-        if (terms.length > 1)
-          throw new Error("PropertyCase accepts exactly 1 string");
-        if (!options.caps || typeof options.caps !== "object" || !Object.keys(options.caps).length)
-          throw new Error("PropertyCase requires a caps object with at least one capability");
-        const unknown = Object.keys(options.caps).filter((c) => !knownCaps[c]);
-        if (unknown.length)
-          throw new Error("PropertyCase: don't know how to test these capabilities: " + unknown.join(", "));
-        this.expr = this.parse(terms[0]);
-        this.caps = options.caps;
-        if (this.caps.linear) {
-          delete this.caps.linear;
-          this.caps.duplicate = false;
-          this.caps.discard = false;
-          this.caps.normal = true;
-        }
-        if (this.caps.affine) {
-          delete this.caps.affine;
-          this.caps.normal = true;
-          this.caps.duplicate = false;
-        }
-      }
-      check(...expr) {
-        const start = this.expr.apply(expr);
-        const r = start.run({ max: this.max });
-        const guess = r.expr.infer({ max: this.max });
-        const reason = [];
-        for (const cap in this.caps) {
-          if (guess[cap] !== this.caps[cap])
-            reason.push("expected property " + cap + " to be " + this.caps[cap] + ", found " + guess[cap]);
+    if (opt.numbers) opt.allow.add("+");
+    else opt.allow.delete("+");
+    const tokens = combChars.split(source);
+    const empty = new Empty();
+    const stack = [empty];
+    const context = options.scope || FreeVar.global;
+    for (const c of tokens) {
+      if (c === "(")
+        stack.push(empty);
+      else if (c === ")") {
+        if (stack.length < 2)
+          throw new Error("unbalanced input: extra closing parenthesis" + source);
+        const x = postParse(stack.pop());
+        const f = stack.pop();
+        stack.push(f.apply(x));
+      } else if (c === "->") {
+        if (!opt.lambdas)
+          throw new Error("Lambdas not supported, allow them explicitly");
+        stack.push(new PartialLambda(stack.pop()));
+      } else if (c.match(/^[0-9]+$/)) {
+        if (!opt.numbers)
+          throw new Error("Church numbers not supported, allow them explicitly");
+        const f = stack.pop();
+        stack.push(f.apply(new Church(Number.parseInt(c))));
+      } else {
+        const f = stack.pop();
+        if (!env[c] && this.known[c] && !opt.allow.has(c)) {
+          throw new Error("Term '" + c + "' is not in the restricted set " + [...opt.allow].sort().join(" "));
         }
-        return {
-          pass: !reason.length,
-          reason: reason ? reason.join("\n") : null,
-          steps: r.steps,
-          start,
-          found: r.expr,
-          case: this,
-          note: this.note,
-          args: expr
-        };
+        const x = env[c] ?? this.known[c] ?? (env[c] = new FreeVar(c, context));
+        stack.push(f.apply(x));
       }
+    }
+    if (stack.length !== 1) {
+      throw new Error("unbalanced input: missing " + (stack.length - 1) + " closing parenthesis:" + source);
+    }
+    return postParse(stack.pop());
+  }
+  toJSON() {
+    return {
+      version: "1.1.1",
+      // set to incremented package.json version whenever SKI serialization changes
+      allow: this.showRestrict("+"),
+      numbers: this.hasNumbers,
+      lambdas: this.hasLambdas,
+      annotate: this.annotate,
+      terms: this.declare()
     };
-    var Subst = class {
-      /**
-       * @descr A placeholder object with exactly n free variables to be substituted later.
-       * @param {Expr} expr
-       * @param {FreeVar[]} env
-       */
-      constructor(expr, env) {
-        this.expr = expr;
-        this.env = env;
-      }
-      apply(list) {
-        if (list.length !== this.env.length)
-          throw new Error("Subst: expected " + this.env.length + " terms, got " + list.length);
-        let expr = this.expr;
-        for (let i = 0; i < this.env.length; i++)
-          expr = expr.subst(this.env[i], list[i]) ?? expr;
-        return expr;
-      }
+  }
+  /**
+  *  Public static shortcuts to common functions (see also ./extras.js)
+  */
+  /**
+  * @desc Create a proxy object that generates variables on demand,
+  *       with names corresponding to the property accessed.
+  *       Different invocations will return distinct variables,
+  *       even if with the same name.
+  *
+  *
+  * @example const {x, y, z} = SKI.vars();
+  *          x.name; // 'x'
+  *          x instanceof FreeVar; // true
+  *          x.apply(y).apply(z); // x(y)(z)
+  *
+  * @template T
+  * @param {T} [scope] - optional context to bind the generated variables to
+  * @return {{[key: string]: FreeVar}}
+  */
+};
+
+// src/quest.ts
+var Quest = class {
+  constructor(options) {
+    const { input, cases, allow, numbers, lambdas, engine, engineFull, ...meta } = options;
+    const env = options.env ?? [];
+    this.engineFull = engineFull ?? new Parser();
+    this.engine = engine ?? this.engineFull;
+    this.restrict = { allow, numbers: numbers ?? false, lambdas: lambdas ?? false };
+    this.env = {};
+    const jar = {};
+    for (const term of env ?? []) {
+      const expr = this.engineFull.parse(term, { env: jar, scope: this });
+      if (expr instanceof Alias)
+        this.env[expr.name] = new Alias(expr.name, expr.impl, { terminal: true, canonize: false });
+      else if (expr instanceof FreeVar)
+        this.env[expr.name] = expr;
+      else
+        throw new Error("Unsupported given variable type: " + term);
+    }
+    this.input = [];
+    for (const term of Array.isArray(input) ? input : [input])
+      this.addInput(term);
+    if (!this.input.length)
+      throw new Error("Quest needs at least one input placeholder");
+    this.envFull = { ...this.env, ...jar };
+    for (const term of this.input) {
+      if (term.name in this.envFull)
+        throw new Error("input placeholder name is duplicated or clashes with env: " + term.name);
+      this.envFull[term.name] = term.placeholder;
+    }
+    this.cases = [];
+    this.name = meta.name ?? meta.title;
+    meta.intro = list2str(meta.intro ?? meta.descr);
+    this.intro = meta.intro;
+    this.id = meta.id;
+    this.meta = meta;
+    for (const c of cases ?? [])
+      this.add(...c);
+  }
+  /**
+   *   Display allowed terms based on what engine thinks of this.env + this.restrict.allow
+   *   @return {string}
+   */
+  allowed() {
+    const allow = this.restrict.allow ?? "";
+    const env = Object.keys(this.env).sort();
+    return allow ? this.engine.showRestrict(allow + "+" + env.join(" ")) : env.map((s) => "+" + s).join(" ");
+  }
+  addInput(term) {
+    if (typeof term !== "object")
+      term = { name: term };
+    if (typeof term.name !== "string")
+      throw new Error("quest 'input' field must be a string or a {name: string, ...} object");
+    const full = term;
+    full.placeholder = new FreeVar(term.name);
+    this.input.push(full);
+  }
+  /**
+   *
+   * @param {{} | string} opt
+   * @param {string} terms
+   * @return {Quest}
+   */
+  add(opt, ...terms) {
+    let o;
+    if (typeof opt === "string") {
+      terms.unshift(opt);
+      o = {};
+    } else
+      o = { ...opt };
+    o.engine = o.engine ?? this.engineFull;
+    o.env = o.env ?? this.envFull;
+    const input = this.input.map((t) => t.placeholder);
+    this.cases.push(
+      o.caps ? new PropertyCase(input, o, terms) : new ExprCase(input, o, terms)
+    );
+    return this;
+  }
+  /**
+   * @description Statefully parse a list of strings into expressions or fancy aliases thereof.
+   * @param {string[]} input
+   * @return {{terms: Expr[], weight: number}}
+   */
+  prepare(...input) {
+    if (input.length !== this.input.length)
+      throw new Error("Solutions provided " + input.length + " terms where " + this.input.length + " are expected");
+    let weight = 0;
+    const prepared = [];
+    const jar = { ...this.env };
+    for (let i = 0; i < input.length; i++) {
+      const spec = this.input[i];
+      const impl = this.engine.parse(input[i], {
+        env: jar,
+        allow: spec.allow ?? this.restrict.allow,
+        numbers: spec.numbers ?? this.restrict.numbers,
+        lambdas: spec.lambdas ?? this.restrict.lambdas
+      });
+      const arsenal = { ...this.engine.getTerms(), ...jar };
+      weight += impl.fold(0, (a, e) => {
+        if (e instanceof Named && arsenal[e.name] === e)
+          return control.prune(a + 1);
+      });
+      const expr = impl instanceof FreeVar ? impl : new Alias(spec.fancy ?? spec.name, impl, { terminal: true, canonize: false });
+      jar[spec.name] = expr;
+      prepared.push(expr);
+    }
+    return {
+      prepared,
+      weight
     };
-    var Group = class {
-      constructor(options) {
-        this.name = options.name;
-        this.intro = list2str(options.intro);
-        this.id = options.id;
-        if (options.content)
-          this.content = options.content.map((c) => c instanceof Quest2 ? c : new Quest2(c));
-      }
-      verify(options) {
-        const findings = {};
-        const id = checkId(this.id, options.seen);
-        if (id)
-          findings[this.id] = id;
-        for (const field of ["name", "intro"]) {
-          const found = checkHtml(this[field]);
-          if (found)
-            findings[field] = found;
-        }
-        findings.content = this.content.map((q) => q.verify(options));
-        return findings;
-      }
+  }
+  /**
+   *
+   * @param {string} input
+   * @return {QuestResult}
+   */
+  check(...input) {
+    try {
+      const { prepared, weight } = this.prepare(...input);
+      const details = this.cases.map((c) => c.check(...prepared));
+      const pass = details.reduce((acc, val) => acc && val.pass, true);
+      const steps = details.reduce((acc, val) => acc + val.steps, 0);
+      return {
+        expr: prepared[0],
+        input: prepared,
+        pass,
+        steps,
+        details,
+        weight
+      };
+    } catch (e) {
+      return { pass: false, details: [], exception: e, steps: 0, input };
+    }
+  }
+  verify(options) {
+    const findings = this.verifyMeta(options);
+    if (options.solutions) {
+      const solCheck = this.verifySolutions(options.solutions);
+      if (solCheck)
+        findings.solutions = solCheck;
+    }
+    if (options.seen) {
+      if (!this.id)
+        findings.seen = "No id in quest " + (this.name ?? "(unnamed)");
+      if (options.seen.has(this.id))
+        findings.seen = "Duplicate quest id " + this.id;
+      options.seen.add(this.id);
+    }
+    return Object.keys(findings).length ? findings : null;
+  }
+  /**
+   * @desc Verify that solutions that are expected to pass/fail do so.
+   * @param {SelfCheck|{[key: string]: SelfCheck}} dataset
+   * @return {{shouldPass: {input: string[], result: QuestResult}[], shouldFail: {input: string[], result: QuestResult}[]} | null}
+   */
+  verifySolutions(dataset) {
+    if (typeof dataset === "object" && !Array.isArray(dataset.accepted) && !Array.isArray(dataset.rejected)) {
+      if (!this.id || !dataset[this.id])
+        return null;
+    }
+    const byId = this.id !== void 0 ? dataset[this.id] : void 0;
+    const { accepted = [], rejected = [] } = byId ?? dataset;
+    const ret = { shouldPass: [], shouldFail: [] };
+    for (const input of accepted) {
+      const result = this.check(...input);
+      if (!result.pass)
+        ret.shouldPass.push({ input, result });
+    }
+    for (const input of rejected) {
+      const result = this.check(...input);
+      if (result.pass)
+        ret.shouldFail.push({ input, result });
+    }
+    return ret.shouldFail.length + ret.shouldPass.length ? ret : null;
+  }
+  verifyMeta(options = {}) {
+    const findings = {};
+    for (const field of ["name", "intro"]) {
+      const found = checkHtml(this[field]);
+      if (found)
+        findings[field] = found;
+    }
+    if (options.date) {
+      const date = new Date(this.meta?.created_at);
+      if (isNaN(date.getTime()))
+        findings.date = "invalid date format: " + this.meta?.created_at;
+      else if (date.getTime() < (/* @__PURE__ */ new Date("2024-07-15")).getTime() || date.getTime() > (/* @__PURE__ */ new Date()).getTime())
+        findings.date = "date out of range: " + this.meta?.created_at;
+    }
+    return findings;
+  }
+  /**
+     *
+     * @return {TestCase[]}
+     */
+  show() {
+    return [...this.cases];
+  }
+};
+var Case = class {
+  constructor(input, options) {
+    this.max = options.max ?? 1e3;
+    this.note = options.note;
+    this.env = { ...options.env ?? {} };
+    this.input = input;
+    this.engine = options.engine;
+  }
+  parse(src) {
+    return new Subst(this.engine.parse(src, { env: this.env, scope: this }), this.input);
+  }
+  /**
+   * @param {Expr} expr
+   * @return {CaseResult}
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  check(..._expr) {
+    throw new Error("not implemented");
+  }
+};
+var ExprCase = class extends Case {
+  /**
+   * @param {FreeVar[]} input
+   * @param {{
+   *    max?: number,
+   *    note?: string,
+   *    env?: {string: Expr},
+   *    engine?: Parser
+   * }} options
+   * @param {[e1: string, e2: string]} terms
+   */
+  constructor(input, options, terms) {
+    if (terms.length !== 2)
+      throw new Error("Case accepts exactly 2 strings");
+    super(input, options);
+    [this.e1, this.e2] = terms.map((s) => this.parse(s));
+  }
+  check(...args) {
+    const e1 = this.e1.apply(args);
+    const r1 = e1.run({ max: this.max });
+    const e2 = this.e2.apply(args);
+    const r2 = e2.run({ max: this.max });
+    let reason = null;
+    if (!r1.final || !r2.final)
+      reason = "failed to reach normal form in " + this.max + " steps";
+    else
+      reason = r1.expr.diff(r2.expr);
+    return {
+      pass: !reason,
+      reason: reason ?? void 0,
+      steps: r1.steps,
+      start: e1,
+      found: r1.expr,
+      expected: r2.expr,
+      note: this.note,
+      args,
+      case: this
     };
-    function list2str(str) {
-      if (str === void 0 || typeof str === "string")
-        return str;
-      return Array.isArray(str) ? str.join(" ") : "" + str;
+  }
+};
+var knownCaps = {
+  normal: true,
+  proper: true,
+  discard: true,
+  duplicate: true,
+  linear: true,
+  affine: true,
+  arity: true
+};
+var PropertyCase = class extends Case {
+  // test that an expression uses all of its inputs exactly once
+  constructor(input, options, terms) {
+    super(input, options);
+    if (terms.length > 1)
+      throw new Error("PropertyCase accepts exactly 1 string");
+    if (!options.caps || typeof options.caps !== "object" || !Object.keys(options.caps).length)
+      throw new Error("PropertyCase requires a caps object with at least one capability");
+    const unknown = Object.keys(options.caps).filter((c) => !knownCaps[c]);
+    if (unknown.length)
+      throw new Error("PropertyCase: don't know how to test these capabilities: " + unknown.join(", "));
+    this.expr = this.parse(terms[0]);
+    this.caps = { ...options.caps };
+    if (this.caps.linear) {
+      delete this.caps.linear;
+      this.caps.duplicate = false;
+      this.caps.discard = false;
+      this.caps.normal = true;
     }
-    function checkId(id, seen) {
-      if (id === void 0)
-        return "missing";
-      if (typeof id !== "string" && typeof id !== "number")
-        return "is a " + typeof id;
-      if (seen) {
-        if (seen.has(id))
-          return "duplicate id " + id;
-        seen.add(id);
-      }
+    if (this.caps.affine) {
+      delete this.caps.affine;
+      this.caps.normal = true;
+      this.caps.duplicate = false;
     }
-    function checkHtml(str) {
-      if (str === void 0)
-        return "missing";
-      if (typeof str !== "string")
-        return "not a string but " + typeof str;
-      const tagStack = [];
-      const tagRegex = /<\/?([a-z]+)(?:\s[^>]*)?>/gi;
-      let match;
-      while ((match = tagRegex.exec(str)) !== null) {
-        const [fullTag, tagName] = match;
-        if (fullTag.startsWith("</")) {
-          if (tagStack.length === 0 || tagStack.pop() !== tagName)
-            return `Unmatched closing tag: </${tagName}>`;
-        } else {
-          tagStack.push(tagName);
-        }
-      }
-      if (tagStack.length > 0)
-        return `Unclosed tags: ${tagStack.join(", ")}`;
-      return null;
+  }
+  check(...expr) {
+    const start = this.expr.apply(expr);
+    const r = start.run({ max: this.max });
+    const guess = r.expr.infer({ max: this.max });
+    const reason = [];
+    for (const cap in this.caps) {
+      if (guess[cap] !== this.caps[cap])
+        reason.push("expected property " + cap + " to be " + this.caps[cap] + ", found " + guess[cap]);
     }
-    Quest2.Group = Group;
-    Quest2.Case = Case;
-    module2.exports = { Quest: Quest2 };
+    return {
+      pass: !reason.length,
+      reason: reason.length ? reason.join("\n") : void 0,
+      steps: r.steps,
+      start,
+      found: r.expr,
+      case: this,
+      note: this.note,
+      args: expr
+    };
   }
-});
+};
+var Subst = class {
+  constructor(expr, env) {
+    this.expr = expr;
+    this.env = env;
+  }
+  apply(list) {
+    if (list.length !== this.env.length)
+      throw new Error("Subst: expected " + this.env.length + " terms, got " + list.length);
+    let expr = this.expr;
+    for (let i = 0; i < this.env.length; i++)
+      expr = expr.subst(this.env[i], list[i]) ?? expr;
+    return expr;
+  }
+};
+var Group = class {
+  constructor(options) {
+    this.name = options.name;
+    this.intro = list2str(options.intro);
+    this.id = options.id;
+    if (options.content)
+      this.content = options.content.map((c) => c instanceof Quest ? c : new Quest(c));
+  }
+  verify(options) {
+    const findings = {};
+    const id = checkId(this.id, options.seen);
+    if (id)
+      findings.id = id;
+    for (const field of ["name", "intro"]) {
+      const found = checkHtml(this[field]);
+      if (found)
+        findings[field] = found;
+    }
+    findings.content = this.content.map((q) => q.verify(options));
+    return findings;
+  }
+};
+function list2str(str) {
+  if (str === void 0 || typeof str === "string")
+    return str;
+  return Array.isArray(str) ? str.join(" ") : "" + str;
+}
+function checkId(id, seen) {
+  if (id === void 0)
+    return "missing";
+  if (typeof id !== "string" && typeof id !== "number")
+    return "is a " + typeof id;
+  if (seen) {
+    if (seen.has(id))
+      return "duplicate id " + id;
+    seen.add(id);
+  }
+}
+function checkHtml(str) {
+  if (str === void 0)
+    return "missing";
+  if (typeof str !== "string")
+    return "not a string but " + typeof str;
+  const tagStack = [];
+  const tagRegex = /<\/?([a-z]+)(?:\s[^>]*)?>/gi;
+  let match;
+  while ((match = tagRegex.exec(str)) !== null) {
+    const [fullTag, tagName] = match;
+    if (fullTag.startsWith("</")) {
+      if (tagStack.length === 0 || tagStack.pop() !== tagName)
+        return `Unmatched closing tag: </${tagName}>`;
+    } else {
+      tagStack.push(tagName);
+    }
+  }
+  if (tagStack.length > 0)
+    return `Unclosed tags: ${tagStack.join(", ")}`;
+  return null;
+}
+Quest.Group = Group;
+Quest.Case = Case;
 
-// src/extras.js
-var require_extras = __commonJS({
-  "src/extras.js"(exports2, module2) {
-    "use strict";
-    var { Expr, Alias, FreeVar } = require_expr();
-    var { Quest: Quest2 } = require_quest();
-    function search(seed, options, predicate) {
-      const {
-        depth = 16,
-        infer = true,
-        progressInterval = 1e3
-      } = options;
-      const hasSeen = infer && !options.noskip;
-      const cache = [[]];
-      let total = 0;
-      let probed = 0;
-      const seen = {};
-      const maybeProbe = (term) => {
-        total++;
-        const props = infer ? term.infer({ max: options.max, maxArgs: options.maxArgs }) : null;
-        if (hasSeen && props.expr) {
-          if (seen[props.expr])
-            return { res: -1 };
-          seen[props.expr] = true;
-        }
-        probed++;
-        const res = predicate(term, props);
-        return { res, props };
-      };
-      for (const term of seed) {
-        const { res } = maybeProbe(term);
-        if (res > 0)
-          return { expr: term, total, probed, gen: 1 };
-        else if (res < 0)
-          continue;
-        cache[0].push(term);
-      }
-      let lastProgress;
-      for (let gen = 1; gen < depth; gen++) {
-        if (options.progress) {
-          options.progress({ gen, total, probed, step: true });
-          lastProgress = total;
-        }
-        for (let i = 0; i < gen; i++) {
-          for (const a of cache[gen - i - 1] || []) {
-            for (const b of cache[i] || []) {
-              if (total >= options.tries)
-                return { total, probed, gen, ...options.retain ? { cache } : {} };
-              if (options.progress && total - lastProgress >= progressInterval) {
-                options.progress({ gen, total, probed, step: false });
-                lastProgress = total;
-              }
-              const term = a.apply(b);
-              const { res, props } = maybeProbe(term);
-              if (res > 0)
-                return { expr: term, total, probed, gen, ...options.retain ? { cache } : {} };
-              else if (res < 0)
-                continue;
-              const offset = infer ? (props.expr ? 0 : 3) + (props.dup ? 1 : 0) + (props.proper ? 0 : 1) : 0;
-              if (!cache[gen + offset])
-                cache[gen + offset] = [];
-              cache[gen + offset].push(term);
-            }
+// src/extras.ts
+function search(seed, options, predicate) {
+  const {
+    depth = 16,
+    infer = true,
+    progressInterval = 1e3
+  } = options;
+  const hasSeen = infer && !options.noskip;
+  const cache = [[]];
+  let total = 0;
+  let probed = 0;
+  const seen = {};
+  const maybeProbe = (term) => {
+    total++;
+    const props = infer ? term.infer({ max: options.max, maxArgs: options.maxArgs }) : null;
+    if (hasSeen && props && props.expr) {
+      const key = String(props.expr);
+      if (seen[key])
+        return { res: -1, props };
+      seen[key] = true;
+    }
+    probed++;
+    const res = predicate(term, props);
+    return { res, props };
+  };
+  for (const term of seed) {
+    const { res = 0 } = maybeProbe(term);
+    if (res > 0)
+      return { expr: term, total, probed, gen: 1 };
+    else if (res < 0)
+      continue;
+    cache[0].push(term);
+  }
+  let lastProgress = 0;
+  for (let gen = 1; gen < depth; gen++) {
+    if (options.progress) {
+      options.progress({ gen, total, probed, step: true });
+      lastProgress = total;
+    }
+    for (let i = 0; i < gen; i++) {
+      for (const a of cache[gen - i - 1] || []) {
+        for (const b of cache[i] || []) {
+          if (total >= (options.tries ?? Infinity))
+            return { total, probed, gen, ...options.retain ? { cache } : {} };
+          if (options.progress && total - lastProgress >= progressInterval) {
+            options.progress({ gen, total, probed, step: false });
+            lastProgress = total;
           }
+          const term = a.apply(b);
+          const { res, props } = maybeProbe(term);
+          if ((res ?? 0) > 0)
+            return { expr: term, total, probed, gen, ...options.retain ? { cache } : {} };
+          else if ((res ?? 0) < 0)
+            continue;
+          const offset = infer && props ? (props.expr ? 0 : 3) + (props.dup ? 1 : 0) + (props.proper ? 0 : 1) : 0;
+          if (!cache[gen + offset])
+            cache[gen + offset] = [];
+          cache[gen + offset].push(term);
         }
       }
-      return { total, probed, gen: depth, ...options.retain ? { cache } : {} };
     }
-    function deepFormat(obj, options = {}) {
-      if (obj instanceof Expr)
-        return obj.format(options);
-      if (obj instanceof Quest2)
-        return "Quest(" + obj.name + ")";
-      if (obj instanceof Quest2.Case)
-        return "Quest.Case";
-      if (Array.isArray(obj))
-        return obj.map(deepFormat);
-      if (typeof obj !== "object" || obj === null || obj.constructor !== Object)
-        return obj;
-      const out = {};
-      for (const key in obj)
-        out[key] = deepFormat(obj[key]);
-      return out;
-    }
-    function declare(expr, env) {
-      const res = Expr.extras.toposort([expr], env);
-      return res.list.map((s) => {
-        if (s instanceof Alias)
-          return s.name + "=" + s.impl.format({ inventory: res.env });
-        if (s instanceof FreeVar)
-          return s.name + "=";
-        return s.format({ inventory: res.env });
-      }).join("; ");
-    }
-    function foldr(expr, fun) {
-      const [head, ...tail] = expr.unroll();
-      return fun(head, tail.map((e) => foldr(e, fun)));
-    }
-    module2.exports = { search, deepFormat, declare, foldr };
   }
-});
+  return { total, probed, gen: depth, ...options.retain ? { cache } : {} };
+}
+function deepFormat(obj, options = {}) {
+  if (obj instanceof Expr)
+    return obj.format(options);
+  if (obj instanceof Quest)
+    return "Quest(" + obj.name + ")";
+  if (obj instanceof Quest.Case)
+    return "Quest.Case";
+  if (Array.isArray(obj))
+    return obj.map((item) => deepFormat(item, options));
+  if (typeof obj !== "object" || obj === null || obj.constructor !== Object)
+    return obj;
+  const out = {};
+  for (const key in obj)
+    out[key] = deepFormat(obj[key], options);
+  return out;
+}
+function declare(expr, env = {}) {
+  const res = toposort([expr], env);
+  return res.list.map((s) => {
+    if (s instanceof Alias)
+      return s.name + "=" + s.impl.format({ inventory: res.env });
+    if (s instanceof FreeVar)
+      return s.name + "=";
+    return s.format({ inventory: res.env });
+  }).join("; ");
+}
+var extras = { search, deepFormat, declare, toposort };
 
-// index.js
-var { SKI } = require_parser();
-var { Quest } = require_quest();
-var extras = require_extras();
-SKI.Quest = Quest;
-SKI.extras = { ...extras, ...SKI.classes.Expr.extras };
-if (typeof process === "object" && process.env.SKI_REPL && typeof global !== "undefined") {
-  global.SKI = SKI;
+// src/index.ts
+extras.toposort = toposort;
+var SKI = class extends Parser {
+  static {
+    this.native = native;
+  }
+  static {
+    this.control = control;
+  }
+  static {
+    this.classes = classes;
+  }
+  static {
+    // TODO declare in a loop?
+    this.B = native.B;
+  }
+  static {
+    this.C = native.C;
+  }
+  static {
+    this.I = native.I;
+  }
+  static {
+    this.K = native.K;
+  }
+  static {
+    this.S = native.S;
+  }
+  static {
+    this.W = native.W;
+  }
+  // variable generator shortcut
+  static vars(scope = {}) {
+    const vars = {};
+    return new Proxy(vars, {
+      get(target, prop) {
+        if (!(prop in target))
+          target[prop] = new FreeVar(prop, scope);
+        return target[prop];
+      }
+    });
+  }
+  static church(n) {
+    return new Church(n);
+  }
+  static {
+    this.extras = extras;
+  }
+  static {
+    this.Quest = Quest;
+  }
+};
+var g = globalThis;
+if (g.process?.env.SKI_REPL) {
+  g.SKI = SKI;
   console.log("SKI_REPL activated, try `new SKI();`");
 }
 if (typeof window !== "undefined")
   window.SKI = SKI;
-module.exports = { SKI, Quest };
 //# sourceMappingURL=ski-interpreter.cjs.js.map