@dallaylaen/ski-interpreter 2.2.0 → 2.2.1

package/lib/ski-interpreter.cjs.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../src/internal.js", "../src/expr.js", "../src/parser.js", "../src/quest.js", "../src/extras.js", "../index.js"],
-  "sourcesContent": ["class Tokenizer {\n  /**\n   * @desc Create a tokenizer that splits strings into tokens according to the given terms.\n   * The terms are interpreted as regular expressions, and are sorted by length\n   * to ensure that longer matches are preferred over shorter ones.\n   * @param {...string|RegExp} terms\n   */\n  constructor (...terms) {\n    const src = '$|(\\\\s+)|' + terms\n      .map(s => '(?:' + s + ')')\n      .sort((a, b) => b.length - a.length)\n      .join('|');\n    this.rex = new RegExp(src, 'gys');\n  }\n\n  /**\n   * @desc Split the given string into tokens according to the terms specified in the constructor.\n   * @param {string} str\n   * @return {string[]}\n   */\n  split (str) {\n    this.rex.lastIndex = 0;\n    const list = [...str.matchAll(this.rex)];\n\n    // did we parse everything?\n    const eol = list.pop();\n    const last = eol?.index ?? 0;\n\n    if (last !== str.length) {\n      throw new Error('Unknown tokens at pos ' + last + '/' + str.length\n                + ' starting with ' + str.substring(last));\n    }\n\n    // skip whitespace\n    return list.filter(x => x[1] === undefined).map(x => x[0]);\n  }\n}\n\nconst tokRestrict = new Tokenizer('[-=+]', '[A-Z]', '\\\\b[a-z_][a-z_0-9]*\\\\b');\n\n/**\n * @desc Add ot remove tokens from a set according to a spec string.\n * The spec string is a sequence of tokens, with each group optionally prefixed\n * by one of the operators '=', '+', or '-'.\n * The '=' operator resets the set to contain only the following token(s).\n * @param {Set<string>} set\n * @param {string} [spec]\n * @returns {Set<string>}\n */\nfunction restrict (set, spec) {\n  if (!spec)\n    return set;\n  let out = new Set([...set]);\n  const act = {\n    '=': sym => { out = new Set([sym]); mode = '+'; },\n    '+': sym => { out.add(sym); },\n    '-': sym => { out.delete(sym); },\n  };\n\n  let mode = '=';\n  for (const sym of tokRestrict.split(spec)) {\n    if (act[sym])\n      mode = sym;\n    else\n      act[mode](sym);\n  }\n  return out;\n}\n\nclass ActionWrapper {\n  /**\n   * @template T\n   * @param {T} value\n   * @param {string} action\n   */\n  constructor (value, action) {\n    this.value = value;\n    this.action = action;\n  }\n}\n\n/**\n * @private\n * @template T\n * @param {T|ActionWrapper<T>} value\n * @returns {[T?, string|undefined]}\n */\nfunction unwrap (value) {\n  if (value instanceof ActionWrapper)\n    return [value.value ?? undefined, value.action];\n  return [value ?? undefined, undefined];\n}\n\n/**\n *\n * @private\n * @template T\n * @param {string} action\n * @returns {function(T): ActionWrapper<T>}\n */\nfunction prepareWrapper (action) {\n  return value => new ActionWrapper(value, action);\n}\n\nmodule.exports = { Tokenizer, restrict, unwrap, prepareWrapper };\n", "'use strict';\n\nconst { unwrap, prepareWrapper } = require('./internal');\n\nconst DEFAULTS = {\n  max:     1000,\n  maxArgs: 32,\n};\n\n/**\n * @template T\n * @typedef {T | { value: T?, action: string } | null} ActionWrapper\n */\nconst control = {\n  descend: prepareWrapper('descend'),\n  prune:   prepareWrapper('prune'),\n  stop:    prepareWrapper('stop'),\n};\n\n/**\n * @typedef {Expr | function(Expr): Partial} Partial\n */\n\nclass Expr {\n  /**\n   *  @descr A combinatory logic expression.\n   *\n   *  Applications, variables, and other terms like combinators per se\n   *  are subclasses of this class.\n   *\n   *  @abstract\n   *  @property {{\n   *    scope?: any,\n   *    env?: { [key: string]: Expr },\n   *    src?: string,\n   *    parser: object,\n   *  }} [context] // TODO proper type\n   */\n  constructor () {\n    if (new.target === Expr)\n      throw new Error('Attempt to instantiate abstract class Expr');\n  }\n\n  /**\n   * @desc apply self to zero or more terms and return the resulting term,\n   * without performing any calculations whatsoever\n   * @param {Expr} args\n   * @return {Expr}\n   */\n  apply (...args) {\n    let expr = this;\n    for (const arg of args)\n      expr = new App(expr, arg);\n    return expr;\n  }\n\n  /**\n   * @desc Replace all aliases in the expression with their definitions, recursively.\n   * @return {Expr}\n   */\n  expand () {\n    return this.traverse(e => {\n      if (e instanceof Alias)\n        return e.impl.expand();\n    }) ?? this;\n  }\n\n  freeOnly () {\n    return !this.any(e => !(e instanceof FreeVar || e instanceof App));\n  }\n\n  /**\n   * @desc Traverse the expression tree, applying change() to each node.\n   *       If change() returns an Expr, the node is replaced with that value.\n   *       Otherwise, the node is left descended further (if applicable)\n   *       or left unchanged.\n   *\n   *       Returns null if no changes were made, or the new expression otherwise.\n   *\n   * @param {(e:Expr) => (Expr|null)} change\n   * @returns {Expr|null}\n   */\n  traverse (change) {\n    return change(this);\n  }\n\n  /**\n   * @desc Returns true if predicate() is true for any subterm of the expression, false otherwise.\n   *\n   * @param {(e: Expr) => boolean} predicate\n   * @returns {boolean}\n   */\n  any (predicate) {\n    return predicate(this);\n  }\n\n  /**\n   * @desc Fold the expression into a single value by recursively applying combine() to its subterms.\n   *       Nodes are traversed in leftmost-outermost order, i.e. the same order as reduction steps are taken.\n   *\n   * null or undefined return value from combine() means \"keep current value and descend further\".\n   *\n   * SKI.control provides primitives to control the folding flow:\n   *  - SKI.control.prune(value) means \"use value and don't descend further into this branch\";\n   *  - SKI.control.stop(value) means \"stop folding immediately and return value\".\n   *  - SKI.control.descend(value) is the default behavior, meaning \"use value and descend further\".\n   *\n   * This method is experimental and may change in the future.\n   *\n   * @experimental\n   * @template T\n   * @param {T} initial\n   * @param {(acc: T, expr: Expr) => ActionWrapper<T>} combine\n   * @returns {T}\n   */\n\n  fold (initial, combine) {\n    const [value, _] = unwrap(this._fold(initial, combine));\n    return value ?? initial;\n  }\n\n  _fold (initial, combine) {\n    return combine(initial, this);\n  }\n\n  /**\n   * @desc rough estimate of the complexity of the term\n   * @return {number}\n   */\n  weight () {\n    return 1;\n  }\n\n  /**\n   * @desc Try to empirically find an equivalent lambda term for the expression,\n   *       returning also the term's arity and some other properties.\n   *\n   *       This is used internally when declaring a Native / Alias term,\n   *       unless {canonize: false} is used.\n   *\n   *       As of current it only recognizes terms that have a normal form,\n   *       perhaps after adding some variables. This may change in the future.\n   *\n   *       Use toLambda() if you want to get a lambda term in any case.\n   *\n   * @param {{max?: number, maxArgs?: number}} options\n   * @return {{\n   *    normal: boolean,\n   *    steps: number,\n   *    expr?: Expr,\n   *    arity?: number,\n   *    proper?: boolean,\n   *    discard?: boolean,\n   *    duplicate?: boolean,\n   *    skip?: Set<number>,\n   *    dup?: Set<number>,\n   * }}\n   */\n  infer (options = {}) {\n    const max = options.max ?? DEFAULTS.max;\n    const maxArgs = options.maxArgs ?? DEFAULTS.maxArgs;\n    const out = this._infer({ max, maxArgs, index: 0 });\n    return out;\n  }\n\n  /**\n   *\n   * @param {{max: number, maxArgs: number, index: number}} options\n   * @param {FreeVar[]} preArgs\n   * @param {number} steps\n   * @returns {{normal: boolean, steps: number}|{normal: boolean, steps: number}|{normal: boolean, steps: number, expr: Lambda|*, arity?: *, skip?: Set<any>, dup?: Set<any>, duplicate, discard, proper: boolean}|*|{normal: boolean, steps: number}}\n   * @private\n   */\n  _infer (options, preArgs = [], steps = 0) {\n    if (preArgs.length > options.maxArgs || steps > options.max)\n      return { normal: false, steps };\n\n    // happy case\n    if (this.freeOnly()) {\n      return {\n        normal: true,\n        steps,\n        ...maybeLambda(preArgs, this),\n      };\n    }\n\n    // try reaching the normal form\n    const next = this.run({ max: (options.max - steps) / 3 });\n    steps += next.steps;\n    if (!next.final)\n      return { normal: false, steps };\n\n    // normal form != this, redo exercise\n    if (next.steps !== 0)\n      return next.expr._infer(options, preArgs, steps);\n\n    // adding more args won't help, bail out\n    // if we're an App, the App's _infer will take care of further args\n    if (this.unroll()[0] instanceof FreeVar)\n      return { normal: false, steps };\n\n    // try adding more arguments, maybe we'll get a normal form then\n    const push = nthvar(preArgs.length + options.index);\n    return this.apply(push)._infer(options, [...preArgs, push], steps);\n  }\n\n  /**\n   * @desc Expand an expression into a list of terms\n   * that give the initial expression when applied from left to right:\n   * ((a, b), (c, d)) => [a, b, (c, d)]\n   *\n   * This can be thought of as an opposite of apply:\n   * fun.apply(...arg).unroll() is exactly [fun, ...args]\n   * (even if ...arg is in fact empty).\n   *\n   * @returns {Expr[]}\n   */\n  unroll () {\n    // currently only used by infer() but may be useful\n    // to convert binary App trees to n-ary or smth\n    return [this];\n  }\n\n  /**\n   * @desc Returns a series of lambda terms equivalent to the given expression,\n   *       up to the provided computation steps limit,\n   *       in decreasing weight order.\n   *\n   *       Unlike infer(), this method will always return something,\n   *       even if the expression has no normal form.\n   *\n   *       See also Expr.walk() and Expr.toSKI().\n   *\n   * @param {{\n   *   max?: number,\n   *   maxArgs?: number,\n   *   varGen?: function(void): FreeVar,\n   *   steps?: number,\n   *   html?: boolean,\n   *   latin?: number,\n   * }} options\n   * @param {number} [maxWeight] - maximum allowed weight of terms in the sequence\n   * @return {IterableIterator<{expr: Expr, steps: number?, comment: string?}>}\n   */\n  * toLambda (options = {}) {\n    const expr = this.traverse(e => {\n      if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)\n        return null; // no change\n      const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });\n      if (!guess.normal)\n        throw new Error('Failed to infer an equivalent  lambda term for ' + e);\n      return guess.expr;\n    }) ?? this;\n    yield * simplifyLambda(expr, options);\n  }\n\n  /**\n   * @desc Rewrite the expression into S, K, and I combinators step by step.\n   *     Returns an iterator yielding the intermediate expressions,\n   *     along with the number of steps taken to reach them.\n   *\n   *     See also Expr.walk() and Expr.toLambda().\n   *\n   * @param {{max?: number}} [options]\n   * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}\n   */\n  * toSKI (options = {}) {\n    // TODO options.max is not actually max, it's the number of steps in one iteration\n    let steps = 0;\n    let expr = this;\n    while (true) {\n      const opt = { max: options.max ?? 1, steps: 0 };\n      const next = expr._rski(opt);\n      const final = opt.steps === 0;\n      yield { expr, steps, final };\n      if (final)\n        break;\n      expr = next;\n      steps += opt.steps;\n    }\n  }\n\n  /**\n   * @desc Internal method for toSKI, which performs one step of the conversion.\n   * @param {{max: number, steps: number}} options\n   * @returns {Expr}\n   * @private\n   */\n  _rski (options) {\n    return this;\n  }\n\n  /**\n   * Replace all instances of plug in the expression with value and return the resulting expression,\n   * or null if no changes could be made.\n   * Lambda terms and applications will never match if used as plug\n   * as they are impossible co compare without extensive computations.\n   * Typically used on variables but can also be applied to other terms, e.g. aliases.\n   * See also Expr.traverse().\n   * @param {Expr} search\n   * @param {Expr} replace\n   * @return {Expr|null}\n   */\n  subst (search, replace) {\n    return this === search ? replace : null;\n  }\n\n  /**\n   * @desc Apply term reduction rules, if any, to the given argument.\n   * A returned value of null means no reduction is possible.\n   * A returned value of Expr means the reduction is complete and the application\n   *     of this and arg can be replaced with the result.\n   * A returned value of a function means that further arguments are needed,\n   *     and can be cached for when they arrive.\n   *\n   * This method is between apply() which merely glues terms together,\n   *     and step() which reduces the whole expression.\n   *\n   * foo.invoke(bar) is what happens inside foo.apply(bar).step() before\n   *     reduction of either foo or bar is attempted.\n   *\n   * The name 'invoke' was chosen to avoid confusion with either 'apply' or 'reduce'.\n   *\n   * @param {Expr} arg\n   * @returns {Partial | null}\n   */\n  invoke (arg) {\n    return null;\n  }\n\n  /**\n   * @desc iterate one step of a calculation.\n   * @return {{expr: Expr, steps: number, changed: boolean}}\n   */\n  step () { return { expr: this, steps: 0, changed: false } }\n\n  /**\n   * @desc Run uninterrupted sequence of step() applications\n   *       until the expression is irreducible, or max number of steps is reached.\n   *       Default number of steps = 1000.\n   * @param {{max: number?, steps: number?, throw: boolean?}|Expr} [opt]\n   * @param {Expr} args\n   * @return {{expr: Expr, steps: number, final: boolean}}\n   */\n  run (opt = {}, ...args) {\n    if (opt instanceof Expr) {\n      args.unshift(opt);\n      opt = {};\n    }\n    let expr = args ? this.apply(...args) : this;\n    let steps = opt.steps ?? 0;\n    // make sure we make at least 1 step, to tell whether we've reached the normal form\n    const max = Math.max(opt.max ?? DEFAULTS.max, 1) + steps;\n    let final = false;\n    for (; steps < max; ) {\n      const next = expr.step();\n      if (!next.changed) {\n        final = true;\n        break;\n      }\n      steps += next.steps;\n      expr = next.expr;\n    }\n    if (opt.throw && !final)\n      throw new Error('Failed to compute expression in ' + max + ' steps');\n    return { final, steps, expr };\n  }\n\n  /**\n   * Execute step() while possible, yielding a brief description of events after each step.\n   * Mnemonics: like run() but slower.\n   * @param {{max: number?}} options\n   * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}\n   */\n  * walk (options = {}) {\n    const max = options.max ?? Infinity;\n    let steps = 0;\n    let expr = this;\n    let final = false;\n\n    while (steps < max) {\n      // 1. calculate\n      // 2. yield _unchanged_ expression\n      // 3. either advance or stop\n      const next = expr.step();\n      if (!next.changed)\n        final = true;\n      yield { expr, steps, final };\n      if (final)\n        break;\n      steps += next.steps;\n      expr = next.expr;\n    }\n  }\n\n  /**\n   * @desc True is the expressions are identical, false otherwise.\n   *       Aliases are expanded.\n   *       Bound variables in lambda terms are renamed consistently.\n   *       However, no reductions are attempted.\n   *\n   *       E.g. a->b->a == x->y->x is true, but a->b->a == K is false.\n   *\n   * @param {Expr} other\n   * @return {boolean}\n   */\n  equals (other) {\n    return !this.diff(other);\n  }\n\n  /**\n   * @desc Recursively compare two expressions and return a string\n   *       describing the first point of difference.\n   *       Returns null if expressions are identical.\n   *\n   *       Aliases are expanded.\n   *       Bound variables in lambda terms are renamed consistently.\n   *       However, no reductions are attempted.\n   *\n   *       Members of the FreeVar class are considered different\n   *       even if they have the same name, unless they are the same object.\n   *       To somewhat alleviate confusion, the output will include\n   *       the internal id of the variable in square brackets.\n   *\n   * @example  \"K(S != I)\" is the result of comparing \"KS\" and \"KI\"\n   * @example  \"S(K([x[13] != x[14]]))K\"\n   *\n   * @param {Expr} other\n   * @param {boolean} [swap]  If true, the order of expressions is reversed in the output.\n   * @returns {string|null}\n   */\n  diff (other, swap = false) {\n    if (this === other)\n      return null;\n    if (other instanceof Alias)\n      return other.impl.diff(this, !swap);\n    return swap\n      ? '[' + other + ' != ' + this  + ']'\n      : '[' + this  + ' != ' + other + ']';\n  }\n\n  /**\n   * @desc Assert expression equality. Can be used in tests.\n   * @param {Expr} expected\n   * @param {string} comment\n   */\n  expect (expected, comment = '') {\n    comment = comment ? comment + ': ' : '';\n    if (!(expected instanceof Expr))\n      throw new Error(comment + 'attempt to expect a combinator to equal something else: ' + expected);\n    const diff = this.diff(expected);\n    if (!diff)\n      return; // all good\n\n    // TODO wanna use AssertionError but webpack doesn't recognize it\n    // still the below hack works for mocha-based tests.\n    const poorMans = new Error(comment + diff);\n    poorMans.expected = expected + '';\n    poorMans.actual = this + '';\n    throw poorMans;\n  }\n\n  /**\n   * @desc Returns string representation of the expression.\n   *       Same as format() without options.\n   * @return {string}\n   */\n  toString () {\n    return this.format();\n  }\n\n  /**\n   * @desc Whether the expression needs parentheses when printed.\n   * @param {boolean} [first] - whether this is the first term in a sequence\n   * @return {boolean}\n   */\n  _braced (first) {\n    return false;\n  }\n\n  /**\n   * @desc Whether the expression can be printed without a space when followed by arg.\n   * @param {Expr} arg\n   * @returns {boolean}\n   * @private\n   */\n  _unspaced (arg) {\n    return this._braced(true);\n  }\n\n  /**\n   * @desc    Stringify the expression with fancy formatting options.\n   *          Said options mostly include wrappers around various constructs in form of ['(', ')'],\n   *          as well as terse and html flags that set up the defaults.\n   *          Format without options is equivalent to toString() and can be parsed back.\n   *\n   * @param   {Object} [options]  - formatting options\n   * @param   {boolean} [options.terse]   - whether to use terse formatting (omitting unnecessary spaces and parentheses)\n   * @param   {boolean} [options.html]    - whether to default to HTML tags & entities.\n   *                                If a named term has fancyName property set, it will be used instead of name in this mode.\n   * @param   {[string, string]} [options.brackets]  - wrappers for application arguments, typically ['(', ')']\n   * @param   {[string, string]} [options.var]       - wrappers for variable names\n   *                                (will default to &lt;var&gt; and &lt;/var&gt; in html mode).\n   * @param   {[string, string, string]} [options.lambda]    - wrappers for lambda abstractions, e.g. ['&lambda;', '.', '']\n   *                                where the middle string is placed between argument and body\n   *                                default is ['', '->', ''] or ['', '-&gt;', ''] for html\n   * @param   {[string, string]} [options.around]    - wrappers around (sub-)expressions.\n   *                                individual applications will not be wrapped, i.e. (a b c) but not ((a b) c)\n   * @param   {[string, string]} [options.redex]     - wrappers around the starting term(s) that have enough arguments to be reduced\n   * @param   {Object<string, Expr>} [options.inventory]     - if given, output aliases in the set as their names\n   *                                and any other aliases as the expansion of their definitions.\n   *                                The default is a cryptic and fragile mechanism dependent on a hidden mutable property.\n   * @returns {string}\n   *\n   * @example foo.format() // equivalent to foo.toString()\n   * @example foo.format({terse: false}) // spell out all parentheses\n   * @example foo.format({html: true}) // use HTML tags and entities\n   * @example foo.format({ around: ['(', ')'], brackets: ['', ''], lambda: ['(', '->', ')'] }) // lisp style, still back-parsable\n   * @exapmle foo.format({ lambda: ['&lambda;', '.', ''] }) // pretty-print for the math department\n   * @example foo.format({ lambda: ['', '=>', ''], terse: false }) // make it javascript\n   * @example foo.format({ inventory: { T } }) // use T as a named term, expand all others\n   *\n   */\n  format (options = {}) {\n    const fallback = options.html\n      ? {\n        brackets: ['(', ')'],\n        space:    ' ',\n        var:      ['<var>', '</var>'],\n        lambda:   ['', '-&gt;', ''],\n        around:   ['', ''],\n        redex:    ['', ''],\n      }\n      : {\n        brackets: ['(', ')'],\n        space:    ' ',\n        var:      ['', ''],\n        lambda:   ['', '->', ''],\n        around:   ['', ''],\n        redex:    ['', ''],\n      }\n    return this._format({\n      terse:     options.terse    ?? true,\n      brackets:  options.brackets ?? fallback.brackets,\n      space:     options.space    ?? fallback.space,\n      var:       options.var      ?? fallback.var,\n      lambda:    options.lambda   ?? fallback.lambda,\n      around:    options.around   ?? fallback.around,\n      redex:     options.redex    ?? fallback.redex,\n      inventory: options.inventory, // TODO better name\n      html:      options.html     ?? false,\n    }, 0);\n  }\n\n  /**\n   * @desc Internal method for format(), which performs the actual formatting.\n   * @param {Object} options\n   * @param {number} nargs\n   * @returns {string}\n   * @private\n   */\n  _format (options, nargs) {\n    throw new Error( 'No _format() method defined in class ' + this.constructor.name );\n  }\n\n  /**\n   * @desc Convert the expression to a JSON-serializable format.\n   * @returns {string}\n   */\n  toJSON () {\n    return this.format();\n  }\n}\n\nclass App extends Expr {\n  /**\n   * @desc Application of fun() to args.\n   * Never ever use new App(fun, arg) directly, use fun.apply(...args) instead.\n   * @param {Expr} fun\n   * @param {Expr} arg\n   */\n  constructor (fun, arg) {\n    super();\n\n    this.arg = arg;\n    this.fun = fun;\n    this.final = false;\n    this.arity = this.fun.arity > 0 ? this.fun.arity - 1 : 0;\n  }\n\n  weight () {\n    return this.fun.weight() + this.arg.weight();\n  }\n\n  _infer (options, preArgs = [], steps = 0) {\n    if (preArgs.length > options.maxArgs || steps > options.max)\n      return { normal: false, steps };\n\n    /*\n     * inside and App there are 3 main possibilities:\n     * 1) The parent infer() actually is able to do the job. Then we just proxy the result.\n     * 2) Both `fun` and `arg` form good enough lambda terms. Then lump them together & return.\n     * 3) We literally have no idea, so we just pick the shortest defined term from the above.\n     */\n\n    const proxy = super._infer(options, preArgs, steps);\n    if (proxy.normal)\n      return proxy;\n    steps = proxy.steps; // reimport extra iterations\n\n    const [first, ...list] = this.unroll();\n    if (!(first instanceof FreeVar))\n      return { normal: false, steps }\n    // TODO maybe do it later\n\n    let discard = false;\n    let duplicate = false;\n    const out = [];\n    for (const term of list) {\n      const guess = term._infer({\n        ...options,\n        maxArgs: options.maxArgs - preArgs.length,\n        max:     options.max - steps,\n        index:   preArgs.length + options.index,\n      });\n      steps += guess.steps;\n      if (!guess.normal)\n        return { normal: false, steps };\n      out.push(guess.expr);\n      discard = discard || guess.discard;\n      duplicate = duplicate || guess.duplicate;\n    }\n\n    return {\n      normal: true,\n      steps,\n      ...maybeLambda(preArgs, first.apply(...out), {\n        discard,\n        duplicate,\n      }),\n    };\n  }\n\n  traverse (change) {\n    const replaced = change(this);\n    if (replaced instanceof Expr)\n      return replaced;\n\n    const fun = this.fun.traverse(change);\n    const arg = this.arg.traverse(change);\n\n    if (!fun && !arg)\n      return null; // no changes\n\n    return (fun ?? this.fun).apply(arg ?? this.arg);\n  }\n\n  any (predicate) {\n    return predicate(this) || this.fun.any(predicate) || this.arg.any(predicate);\n  }\n\n  _fold (initial, combine) {\n    const [value = initial, action = 'descend'] = unwrap(combine(initial, this));\n    if (action === 'prune')\n      return value;\n    if (action === 'stop')\n      return control.stop(value);\n    const [fValue = value, fAction = 'descend'] = unwrap(this.fun._fold(value, combine));\n    if (fAction === 'stop')\n      return control.stop(fValue);\n    const [aValue = fValue, aAction = 'descend'] = unwrap(this.arg._fold(fValue, combine));\n    if (aAction === 'stop')\n      return control.stop(aValue);\n    return aValue;\n  }\n\n  subst (search, replace) {\n    const fun = this.fun.subst(search, replace);\n    const arg = this.arg.subst(search, replace);\n\n    return (fun || arg) ? (fun ?? this.fun).apply(arg ?? this.arg) : null;\n  }\n\n  /**\n   * @return {{expr: Expr, steps: number}}\n   */\n\n  step () {\n    // normal reduction order: first try root, then at most 1 step\n    if (!this.final) {\n      // try to apply rewriting rules, if applicable, at first\n      const partial = this.fun.invoke(this.arg);\n      if (partial instanceof Expr)\n        return { expr: partial, steps: 1, changed: true };\n      else if (typeof partial === 'function')\n        this.invoke = partial; // cache for next time\n\n      // descend into the leftmost term\n      const fun = this.fun.step();\n      if (fun.changed)\n        return { expr: fun.expr.apply(this.arg), steps: fun.steps, changed: true };\n\n      // descend into arg\n      const arg = this.arg.step();\n      if (arg.changed)\n        return { expr: this.fun.apply(arg.expr), steps: arg.steps, changed: true };\n\n      // mark as irreducible\n      this.final = true; // mark as irreducible at root\n    }\n\n    return { expr: this, steps: 0, changed: false };\n  }\n\n  invoke (arg) {\n    // propagate invocation towards the root term,\n    // caching partial applications as we go\n    const partial = this.fun.invoke(this.arg);\n    if (partial instanceof Expr)\n      return partial.apply(arg);\n    else if (typeof partial === 'function') {\n      this.invoke = partial;\n      return partial(arg);\n    } else {\n      // invoke = null => we're uncomputable, cache for next time\n      this.invoke = _ => null;\n      return null;\n    }\n  }\n\n  unroll () {\n    return [...this.fun.unroll(), this.arg];\n  }\n\n  /**\n   * @desc Convert the expression to SKI combinatory logic\n   * @return {Expr}\n   */\n\n  _rski (options) {\n    if (options.steps >= options.max)\n      return this;\n    return this.fun._rski(options).apply(this.arg._rski(options));\n  }\n\n  diff (other, swap = false) {\n    if (!(other instanceof App))\n      return super.diff(other, swap);\n\n    const fun = this.fun.diff(other.fun, swap);\n    if (fun)\n      return fun + '(...)';\n    const arg = this.arg.diff(other.arg, swap);\n    if (arg)\n      return this.fun + '(' + arg + ')';\n    return null;\n  }\n\n  _braced (first) {\n    return !first;\n  }\n\n  _format (options, nargs) {\n    const fun = this.fun._format(options, nargs + 1);\n    const arg = this.arg._format(options, 0);\n    const wrap = nargs ? ['', ''] : options.around;\n    // TODO ignore terse for now\n    if (options.terse && !this.arg._braced(false))\n      return wrap[0] + fun + (this.fun._unspaced(this.arg) ? '' : options.space) + arg + wrap[1];\n    else\n      return wrap[0] + fun + options.brackets[0] + arg + options.brackets[1] + wrap[1];\n  }\n\n  _unspaced (arg) {\n    return this.arg._braced(false) ? true : this.arg._unspaced(arg);\n  }\n}\n\nclass Named extends Expr {\n  /**\n   * @desc An abstract class representing a term named 'name'.\n   *\n   * @param {String} name\n   */\n  constructor (name) {\n    super();\n    if (typeof name !== 'string' || name.length === 0)\n      throw new Error('Attempt to create a named term with improper name');\n    this.name = name;\n  }\n\n  _unspaced (arg) {\n    return !!(\n      (arg instanceof Named) && (\n        (this.name.match(/^[A-Z+]$/) && arg.name.match(/^[a-z+]/i))\n          || (this.name.match(/^[a-z+]/i) && arg.name.match(/^[A-Z+]$/))\n      )\n    );\n  }\n\n  _format (options, nargs) {\n    // NOTE fancyName is not yet official and may change name or meaning\n    const name = options.html ? this.fancyName ?? this.name : this.name;\n    return this.arity > 0 && this.arity <= nargs\n      ? options.redex[0] + name + options.redex[1]\n      : name;\n  }\n}\n\nlet freeId = 0;\n\nclass FreeVar extends Named {\n  /**\n   * @desc A named variable.\n   *\n   * Given the functional nature of combinatory logic, variables are treated\n   * as functions that we don't know how to evaluate just yet.\n   *\n   * By default, two different variables even with the same name are considered different.\n   * They display it via a hidden id property.\n   *\n   * If a scope object is given, however, two variables with the same name and scope\n   * are considered identical.\n   *\n   * @param {string} name - name of the variable\n   * @param {any} scope - an object representing where the variable belongs to.\n   */\n  constructor (name, scope) {\n    super(name);\n    this.id = ++freeId;\n    // TODO temp compatibility mode\n    this.scope = scope === undefined ? this : scope;\n  }\n\n  weight () {\n    return 0;\n  }\n\n  diff (other, swap = false) {\n    if (!(other instanceof FreeVar))\n      return super.diff(other, swap);\n    if (this.name === other.name && this.scope === other.scope)\n      return null;\n    const lhs = this.name + '[' + this.id + ']';\n    const rhs = other.name + '[' + other.id + ']';\n    return swap\n      ? '[' + rhs + ' != ' + lhs + ']'\n      : '[' + lhs + ' != ' + rhs + ']';\n  }\n\n  subst (search, replace) {\n    if (search instanceof FreeVar && search.name === this.name && search.scope === this.scope)\n      return replace;\n    return null;\n  }\n\n  _format (options, nargs) {\n    const name = options.html ? this.fancyName ?? this.name : this.name;\n    return options.var[0] + name + options.var[1];\n  }\n}\n\nclass Native extends Named {\n  /**\n   * @desc A named term with a known rewriting rule.\n   *       'impl' is a function with signature Expr => Expr => ... => Expr\n   *       (see typedef Partial).\n   *       This is how S, K, I, and company are implemented.\n   *\n   *       Note that as of current something like a=>b=>b(a) is not possible,\n   *       use full form instead: a=>b=>b.apply(a).\n   *\n   * @example new Native('K', x => y => x); // constant\n   * @example new Native('Y', function(f) { return f.apply(this.apply(f)); }); // self-application\n   *\n   * @param {String} name\n   * @param {Partial} impl\n   * @param {{note?: string, arity?: number, canonize?: boolean, apply?: function(Expr):(Expr|null) }} [opt]\n   */\n  constructor (name, impl, opt = {}) {\n    super(name);\n    // setup essentials\n    this.invoke  = impl;\n\n    // TODO infer lazily (on demand, only once); app capabilities such as discard and duplicate\n    // try to bootstrap and infer some of our properties\n    const guess = (opt.canonize ?? true) ? this.infer() : { normal: false };\n\n    this.arity = opt.arity || guess.arity || 1;\n    this.note = opt.note ?? guess.expr?.format({ terse: true, html: true, lambda: ['', ' &mapsto; ', ''] });\n  }\n\n  _rski (options) {\n    if (this === native.I || this === native.K || this === native.S || (options.steps >= options.max))\n      return this;\n    const canon = this.infer().expr;\n    if (!canon)\n      return this;\n    options.steps++;\n    return canon._rski(options);\n  }\n}\n\n// predefined global combinator list\n// it is required by toSKI method, otherwise it could've as well be in parse.js\n/**\n * @type {{[key: string]: Native}}\n */\nconst native = {};\nfunction addNative (name, impl, opt) {\n  native[name] = new Native(name, impl, opt);\n}\n\nclass Lambda extends Expr {\n  /**\n   * @desc Lambda abstraction of arg over impl.\n   *     Upon evaluation, all occurrences of 'arg' within 'impl' will be replaced\n   *     with the provided argument.\n   *\n   * Note that 'arg' will be replaced by a localized placeholder, so the original\n   * variable can be used elsewhere without interference.\n   * Listing symbols contained in the lambda will omit such placeholder.\n   *\n   * Legacy ([FreeVar], impl) constructor is supported but deprecated.\n   * It will create a nested lambda expression.\n   *\n   * @param {FreeVar} arg\n   * @param {Expr} impl\n   */\n  constructor (arg, impl) {\n    if (Array.isArray(arg)) {\n      // check args before everything\n      if (arg.length === 0)\n        throw new Error('empty argument list in lambda constructor');\n\n      const [my, ...tail] = arg;\n      const known = new Set([my.name]);\n\n      while (tail.length > 0) {\n        const last = tail.pop();\n        if (known.has(last.name))\n          throw new Error('Duplicate free var name ' + last + ' in lambda expression');\n        known.add(last.name);\n\n        // TODO keep track of arity to speed up execution\n        impl = new Lambda(last, impl);\n      }\n      arg = my;\n    }\n\n    super();\n\n    // localize argument variable and bind it to oneself\n    const local = new FreeVar(arg.name, this);\n    this.arg = local;\n    this.impl = impl.subst(arg, local) ?? impl;\n    this.arity = 1;\n  }\n\n  weight () {\n    return this.impl.weight() + 1;\n  }\n\n  _infer (options, preArgs = [], steps = 0) {\n    if (preArgs.length > options.maxArgs)\n      return { normal: false, steps };\n\n    const push = nthvar(preArgs.length + options.index);\n    return this.invoke(push)._infer(options, [...preArgs, push], steps + 1);\n  }\n\n  invoke (arg) {\n    return this.impl.subst(this.arg, arg) ?? this.impl;\n  }\n\n  traverse (change) {\n    const replaced = change(this);\n    if (replaced instanceof Expr)\n      return replaced;\n\n    // alas no proper shielding of self.arg is possible\n    const impl = this.impl.traverse(change);\n\n    if (!impl)\n      return null; // no changes\n\n    return new Lambda(this.arg, impl);\n  }\n\n  any (predicate) {\n    return predicate(this) || this.impl.any(predicate);\n  }\n\n  _fold (initial, combine) {\n    const [value = initial, action = 'descend'] = unwrap(combine(initial, this));\n    if (action === 'prune')\n      return value;\n    if (action === 'stop')\n      return control.stop(value);\n    const [iValue, iAction] = unwrap(this.impl._fold(value, combine));\n    if (iAction === 'stop')\n      return control.stop(iValue);\n    return iValue ?? value;\n  }\n\n  subst (search, replace) {\n    if (search === this.arg)\n      return null;\n    const change = this.impl.subst(search, replace);\n    return change ? new Lambda(this.arg, change) : null;\n  }\n\n  _rski (options) {\n    const impl = this.impl._rski(options);\n    if (options.steps >= options.max)\n      return new Lambda(this.arg, impl);\n    options.steps++;\n    if (impl === this.arg)\n      return native.I;\n    if (!impl.any(e => e === this.arg))\n      return native.K.apply(impl);\n    if (impl instanceof App) {\n      const { fun, arg } = impl;\n      // try eta reduction\n      if (arg === this.arg && !fun.any(e => e === this.arg))\n        return fun._rski(options);\n      // fall back to S\n      return native.S.apply(\n        (new Lambda(this.arg, fun))._rski(options),\n        (new Lambda(this.arg, arg))._rski(options)\n      );\n    }\n    throw new Error('Don\\'t know how to convert to SKI' + this);\n  }\n\n  diff (other, swap = false) {\n    if (!(other instanceof Lambda))\n      return super.diff(other, swap);\n\n    const t = new FreeVar('t'); // TODO better placeholder name\n\n    const diff = this.invoke(t).diff(other.invoke(t), swap);\n    if (diff)\n      return '(t->' + diff + ')'; // parentheses required to avoid ambiguity\n    return null;\n  }\n\n  _format (options, nargs) {\n    return (nargs > 0 ? options.brackets[0] : '')\n      + options.lambda[0]\n      + this.arg._format(options, 0) // TODO highlight redex if nargs > 0\n      + options.lambda[1]\n      + this.impl._format(options, 0) + options.lambda[2]\n      + (nargs > 0 ? options.brackets[1] : '');\n  }\n\n  _braced (first) {\n    return true;\n  }\n}\n\nclass Church extends Native {\n  /**\n   * @desc Church numeral representing non-negative integer n:\n   *      n f x = f(f(...(f x)...)) with f applied n times.\n   * @param {number} n\n   */\n  constructor (n) {\n    const p = Number.parseInt(n);\n    if (!(p >= 0))\n      throw new Error('Church number must be a non-negative integer');\n    const name = '' + p;\n    const impl = x => y => {\n      let expr = y;\n      for (let i = p; i-- > 0; )\n        expr = x.apply(expr);\n      return expr;\n    };\n\n    super(name, impl, { arity: 2, canonize: false, note: name });\n\n    this.n = p;\n    this.arity = 2;\n  }\n\n  diff (other, swap = false) {\n    if (!(other instanceof Church))\n      return super.diff(other, swap);\n    if (this.n === other.n)\n      return null;\n    return swap\n      ? '[' + other.n + ' != ' + this.n + ']'\n      : '[' + this.n + ' != ' + other.n + ']';\n  }\n\n  _unspaced (arg) {\n    return false;\n  }\n}\n\nfunction waitn (expr, n) {\n  return arg => n <= 1 ? expr.apply(arg) : waitn(expr.apply(arg), n - 1);\n}\n\nclass Alias extends Named {\n  /**\n   * @desc A named alias for an existing expression.\n   *\n   *     Upon evaluation, the alias expands into the original expression,\n   *     unless it has a known arity > 0 and is marked terminal,\n   *     in which case it waits for enough arguments before expanding.\n   *\n   *     A hidden mutable property 'outdated' is used to silently\n   *     replace the alias with its definition in all contexts.\n   *     This is used when declaring named terms in an interpreter,\n   *     to avoid confusion between old and new terms with the same name.\n   *\n   * @param {String} name\n   * @param {Expr} impl\n   * @param {{canonize: boolean?, max: number?, maxArgs: number?, note: string?, terminal: boolean?}} [options]\n   */\n  constructor (name, impl, options = {}) {\n    super(name);\n    if (!(impl instanceof Expr))\n      throw new Error('Attempt to create an alias for a non-expression: ' + impl);\n    this.impl = impl;\n\n    if (options.note)\n      this.note = options.note;\n\n    const guess = options.canonize\n      ? impl.infer({ max: options.max, maxArgs: options.maxArgs })\n      : { normal: false };\n    this.arity = (guess.proper && guess.arity) || 0;\n    this.proper = guess.proper ?? false;\n    this.terminal = options.terminal ?? this.proper;\n    this.canonical = guess.expr;\n    this.invoke = waitn(impl, this.arity);\n  }\n\n  weight () {\n    return this.terminal ? 1 : this.impl.weight();\n  }\n\n  traverse (change) {\n    return change(this) ?? this.impl.traverse(change);\n  }\n\n  any (predicate) {\n    return predicate(this) || this.impl.any(predicate);\n  }\n\n  _fold (initial, combine) {\n    const [value = initial, action = 'descend'] = unwrap(combine(initial, this));\n    if (action === 'prune')\n      return value;\n    if (action === 'stop')\n      return control.stop(value);\n    const [iValue, iAction] = unwrap(this.impl._fold(value, combine));\n    if (iAction === 'stop')\n      return control.stop(iValue);\n    return iValue ?? value;\n  }\n\n  subst (search, replace) {\n    if (this === search)\n      return replace;\n    return this.impl.subst(search, replace);\n  }\n\n  _infer (options, preArgs = [], steps = 0) {\n    return this.impl._infer(options, preArgs, steps);\n  }\n\n  /**\n   *\n   * @return {{expr: Expr, steps: number}}\n   */\n  step () {\n    // arity known = waiting for args to expand\n    if (this.arity > 0)\n      return { expr: this, steps: 0, changed: false };\n    // expanding is a change but it takes 0 steps\n    return { expr: this.impl, steps: 0, changed: true };\n  }\n\n  diff (other, swap = false) {\n    if (this === other)\n      return null;\n    return other.diff(this.impl, !swap);\n  }\n\n  _rski (options) {\n    return this.impl._rski(options);\n  }\n\n  _braced (first) {\n    return this.outdated ? this.impl._braced(first) : false;\n  }\n\n  _format (options, nargs) {\n    const outdated = options.inventory\n      ? options.inventory[this.name] !== this\n      : this.outdated;\n    return outdated ? this.impl._format(options, nargs) : super._format(options, nargs);\n  }\n}\n\n// ----- Expr* classes end here -----\n\n// declare native combinators\naddNative('I', x => x);\naddNative('K', x => _ => x);\naddNative('S', x => y => z => x.apply(z, y.apply(z)));\naddNative('B', x => y => z => x.apply(y.apply(z)));\naddNative('C', x => y => z => x.apply(z).apply(y));\naddNative('W', x => y => x.apply(y).apply(y));\n\naddNative(\n  '+',\n  n => n instanceof Church\n    ? new Church(n.n + 1)\n    : f => x => f.apply(n.apply(f, x)),\n  {\n    note: 'Increase a Church numeral argument by 1, otherwise n => f => x => f(n f x)',\n  }\n);\n\n// utility functions dependent on Expr* classes, in alphabetical order\n\nfunction maybeLambda (args, expr, caps = {}) {\n  const count = new Array(args.length).fill(0);\n  let proper = true;\n  expr.traverse(e => {\n    if (e instanceof FreeVar) {\n      const index = args.findIndex(a => a.name === e.name);\n      if (index >= 0) {\n        count[index]++;\n        return;\n      }\n    }\n    if (!(e instanceof App))\n      proper = false;\n  });\n\n  const skip = new Set();\n  const dup = new Set();\n  for (let i = 0; i < args.length; i++) {\n    if (count[i] === 0)\n      skip.add(i);\n    else if (count[i] > 1)\n      dup.add(i);\n  }\n\n  return {\n    expr:      args.length ? new Lambda(args, expr) : expr,\n    ...(caps.synth ? {} : { arity: args.length }),\n    ...(skip.size ? { skip } : {}),\n    ...(dup.size ? { dup } : {}),\n    duplicate: !!dup.size  || caps.duplicate || false,\n    discard:   !!skip.size || caps.discard   || false,\n    proper,\n  };\n}\n\nfunction nthvar (n) {\n  return new FreeVar('abcdefgh'[n] ?? 'x' + n);\n}\n\n/**\n *\n * @param {Expr} expr\n * @param {{max: number?, maxArgs: number?}} options\n * @param {number} maxWeight\n * @yields {{expr: Expr, steps: number?, comment: string?}}\n */\nfunction * simplifyLambda (expr, options = {}, state = { steps: 0 }) {\n  // expr is a lambda, free variable, or an application thereof\n  // we want to find an equivalent lambda term with less weight\n  // which we do sequentially from leaves to the root of the AST\n\n  yield { expr, steps: state.steps, comment: '(self)' };\n\n  // short-circuit\n  if (expr.freeOnly())\n    return;\n\n  let maxWeight = expr.weight();\n\n  if (expr instanceof Lambda) {\n    for (const term of simplifyLambda(expr.impl, options, state)) {\n      const candidate = new Lambda(expr.arg, term.expr);\n      if (candidate.weight() < maxWeight) {\n        maxWeight = candidate.weight();\n        yield { expr: candidate, steps: state.steps, comment: '(lambda)' + term.comment };\n      }\n    }\n  }\n\n  // fun * arg Descartes product\n  if (expr instanceof App) {\n    // try to split into fun+arg, then try canonization but exposing each step\n    let { fun, arg } = expr;\n\n    for (const term of simplifyLambda(fun, options, state)) {\n      const candidate = term.expr.apply(arg);\n      if (candidate.weight() < maxWeight) {\n        maxWeight = candidate.weight();\n        fun = term.expr;\n        yield { expr: candidate, steps: state.steps, comment: '(fun)' + term.comment };\n      }\n    }\n\n    for (const term of simplifyLambda(arg, options, state)) {\n      const candidate = fun.apply(term.expr);\n      if (candidate.weight() < maxWeight) {\n        maxWeight = candidate.weight();\n        yield { expr: candidate, steps: state.steps, comment: '(arg)' + term.comment };\n      }\n    }\n  }\n\n  const canon = expr.infer({ max: options.max, maxArgs: options.maxArgs });\n  state.steps += canon.steps;\n  if (canon.expr && canon.expr.weight() < maxWeight)\n    yield { expr: canon.expr, steps: state.steps, comment: '(canonical)' };\n}\n\n/**\n * @desc  Sort a list in such a way that dependent terms come after the (named) terms they depend on.\n *        If env is given, only terms listed there are taken into account.\n *        If env is omitted, it will be implied from the list.\n *        If list is omitted, it will default to values of env.\n *        If just one term is given instead of a list, it will be coerced into a list.\n *\n *        No terms outside env + list may ever appear in the result.\n *\n *        The terms in env must be named and their names must match their keys.\n *\n * @param {Expr|Expr[]} list\n * @param {{[s:string]: Named}} env\n * @returns {{list: Expr[], env: {[s:string]: Named}}}\n *\n * @example\n *    const expr = ski.parse(src);\n *    toposort([expr], ski.getTerms()); // returns all terms appearing in Expr in correct order\n */\nfunction toposort (list, env) {\n  if (list instanceof Expr)\n    list = [list];\n  if (env) {\n    // TODO check in[name].name === name\n    if (!list)\n      list = Object.keys(env).sort().map(k => env[k]); // ensure deterministic order\n  } else {\n    if (!list)\n      return [];\n    if (!env) {\n      env = {};\n      for (const item of list) {\n        if (!(item instanceof Named))\n          continue;\n        if (env[item.name])\n          throw new Error('duplicate name ' + item);\n        env[item.name] = item;\n      }\n    }\n  }\n\n  const out = [];\n  const seen = new Set();\n  const rec = term => {\n    if (seen.has(term))\n      return;\n    term.fold(null, (acc, e) => {\n      if (e !== term && e instanceof Named && env[e.name] === e) {\n        rec(e);\n        return Expr.control.prune(null);\n      }\n    });\n    out.push(term);\n    seen.add(term);\n  };\n\n  for (const term of list)\n    rec(term);\n\n  return {\n    list: out,\n    env,\n  };\n}\n\nExpr.native = native;\nExpr.control = control;\nExpr.extras = { toposort };\n\nmodule.exports = { Expr, App, Named, FreeVar, Lambda, Native, Alias, Church };\n", "/**\n * Combinatory logic simulator\n */\n'use strict';\n\nconst { Tokenizer, restrict } = require('./internal');\nconst classes = require('./expr');\n\nconst { Expr, Named, Native, Alias, FreeVar, Lambda, Church } = classes;\nconst { native } = Expr;\n\nclass Empty extends Expr {\n  apply (...args) {\n    return args.length ? args.shift().apply(...args) : this;\n  }\n\n  postParse () {\n    throw new Error('Attempt to use empty expression () as a term');\n  }\n}\n\nclass PartialLambda extends Empty {\n  // TODO mutable! rewrite ro when have time\n  constructor (term, known = {}) {\n    super();\n    this.impl = new Empty();\n    if (term instanceof FreeVar)\n      this.terms = [term];\n    else if (term instanceof PartialLambda) {\n      if (!(term.impl instanceof FreeVar))\n        throw new Error('Expected FreeVar->...->FreeVar->Expr');\n      this.terms = [...term.terms, term.impl];\n    } else\n      throw new Error('Expected FreeVar or PartialLambda');\n  }\n\n  apply (term, ...tail) {\n    if (term === null || tail.length !== 0 )\n      throw new Error('bad syntax in partial lambda expr');\n    this.impl = this.impl.apply(term);\n    return this;\n  }\n\n  postParse () {\n    return new Lambda(this.terms, this.impl);\n  }\n\n  // uncomment if debugging with prints\n  /* toString () {\n    return this.terms.join('->') + '->' + (this.impl ?? '???');\n  } */\n}\n\nfunction postParse (expr) {\n  return expr.postParse ? expr.postParse() : expr;\n}\n\nconst combChars = new Tokenizer(\n  '[()]', '[A-Z]', '[a-z_][a-z_0-9]*', '\\\\b[0-9]+\\\\b', '->', '\\\\+'\n);\n\nclass SKI {\n  /**\n   *\n   * @param {{\n   *    allow?: string,\n   *    numbers?: boolean,\n   *    lambdas?: boolean,\n   *    terms?: { [key: string]: Expr|string} | string[],\n   *    annotate?: boolean,\n   * }} [options]\n   */\n  constructor (options = {}) {\n    this.annotate = options.annotate ?? false;\n    this.known = { ...native };\n    this.hasNumbers = true;\n    this.hasLambdas = true;\n    this.allow = new Set(Object.keys(this.known));\n\n    // Import terms, if any. Omit native ones\n    if (Array.isArray(options.terms))\n      this.bulkAdd(options.terms);\n    else if (options.terms) {\n      for (const name in options.terms) {\n        // Native terms already handled by allow\n        if (!options.terms[name].match(/^Native:/))\n          this.add(name, options.terms[name]);\n      }\n    }\n\n    // Finally, impose restrictions\n    // We must do it after recreating terms, or else terms reliant on forbidden terms will fail\n    this.hasNumbers = options.numbers ?? true;\n    this.hasLambdas = options.lambdas ?? true;\n    if (options.allow)\n      this.restrict(options.allow);\n  }\n\n  /**\n   * @desc Declare a new term\n   * If the first argument is an Alias, it is added as is.\n   * Otherwise, a new Alias or Native term (depending on impl type) is created.\n   * If note is not provided and this.annotate is true, an automatic note is generated.\n   *\n   * If impl is a function, it should have signature (Expr) => ... => Expr\n   * (see typedef Partial at top of expr.js)\n   *\n   * @example ski.add('T', 'S(K(SI))K', 'swap combinator')\n   * @example ski.add( ski.parse('T = S(K(SI))K') ) // ditto but one-arg form\n   * @example ski.add('T', x => y => y.apply(x), 'swap combinator') // heavy artillery\n   * @example ski.add('Y', function (f) { return f.apply(this.apply(f)); }, 'Y combinator')\n   *\n   * @param {Alias|String} term\n   * @param {String|Expr|function(Expr):Partial} [impl]\n   * @param {String} [note]\n   * @return {SKI} chainable\n   */\n  add (term, impl, note ) {\n    term = this._named(term, impl);\n\n    if (this.annotate && note === undefined) {\n      const guess = term.infer();\n      if (guess.expr)\n        note = guess.expr.format({ terse: true, html: true, lambda: ['', ' &mapsto; ', ''] });\n    }\n    if (note !== undefined)\n      term.note = note;\n\n    if (this.known[term.name])\n      this.known[term.name].outdated = true;\n    this.known[term.name] = term;\n    this.allow.add(term.name);\n\n    return this;\n  }\n\n  _named (term, impl) {\n    if (term instanceof Alias)\n      return new Alias(term.name, term.impl, { canonize: true });\n    if (typeof term !== 'string')\n      throw new Error('add(): term must be an Alias or a string');\n    if (impl === undefined)\n      throw new Error('add(): impl must be provided when term is a string');\n    if (typeof impl === 'string')\n      return new Alias(term, this.parse(impl), { canonize: true });\n    if (impl instanceof Expr)\n      return new Alias(term, impl, { canonize: true });\n    if (typeof impl === 'function')\n      return new Native(term, impl);\n    // idk what this is\n    throw new Error('add(): impl must be an Expr, a string, or a function with a signature Expr => ... => Expr');\n  }\n\n  maybeAdd (name, impl) {\n    if (this.known[name])\n      this.allow.add(name);\n    else\n      this.add(name, impl);\n    return this;\n  }\n\n  /**\n   * @desc Declare and remove multiple terms at once\n   *       term=impl adds term\n   *       term= removes term\n   * @param {string[]]} list\n   * @return {SKI} chainable\n   */\n  bulkAdd (list) {\n    for (const item of list) {\n      const m = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\\s*=\\s*(.*)$/s);\n      // TODO check all declarations before applying any (but we might need earlier terms for parsing later ones)\n      if (!m)\n        throw new Error('bulkAdd: invalid declaration: ' + item);\n      if (m[2] === '')\n        this.remove(m[1]);\n      else\n        this.add(m[1], this.parse(m[2]));\n    }\n\n    return this;\n  }\n\n  /**\n   * Restrict the interpreter to given terms. Terms prepended with '+' will be added\n   * and terms preceeded with '-' will be removed.\n   * @example ski.restrict('SK') // use the basis\n   * @example ski.restrict('+I') // allow I now\n   * @example ski.restrict('-SKI +BCKW' ); // switch basis\n   * @example ski.restrict('-foo -bar'); // forbid some user functions\n   * @param {string} spec\n   * @return {SKI} chainable\n   */\n  restrict (spec) {\n    this.allow = restrict(this.allow, spec);\n    return this;\n  }\n\n  /**\n   *\n   * @param {string} spec\n   * @return {string}\n   */\n  showRestrict (spec = '+') {\n    const out = [];\n    let prevShort = true;\n    for (const term of [...restrict(this.allow, spec)].sort()) {\n      const nextShort = term.match(/^[A-Z]$/);\n      if (out.length && !(prevShort && nextShort))\n        out.push(' ');\n      out.push(term);\n      prevShort = nextShort;\n    }\n    return out.join('');\n  }\n\n  /**\n   *\n   * @param {String} name\n   * @return {SKI}\n   */\n  remove (name) {\n    this.known[name].outdated = true;\n    delete this.known[name];\n    this.allow.delete(name);\n    return this;\n  }\n\n  /**\n   *\n   * @return {{[key:string]: Native|Alias}}\n   */\n  getTerms () {\n    const out = {};\n    for (const name of Object.keys(this.known)) {\n      if (this.allow.has(name))\n        out[name] = this.known[name];\n    }\n    return out;\n  }\n\n  /**\n   * @desc Export term declarations for use in bulkAdd().\n   * Currently only Alias terms are serialized.\n   * @returns {string[]}\n   */\n  declare () {\n    // TODO accept argument to declare specific terms only\n    const env = this.getTerms();\n\n    // not serializing native terms, and we don't care about free vars\n    for (const name in env) {\n      if (!(env[name] instanceof Alias))\n        delete env[name];\n    }\n\n    // avert conflicts if native terms were redefined:\n    // create a temporary alias for each native term that was redefined;\n    // replace usage of redefined term in subexpressions;\n    // finally, remove the temporary aliases from the output\n    const needDetour = {};\n    let i = 1;\n    for (const name in native) {\n      if (!(env[name] instanceof Alias))\n        continue;\n      while ('tmp' + i in env)\n        i++;\n      const temp = new Alias('tmp' + i, env[name]);\n      needDetour[temp] = env[name];\n      env[temp] = temp;\n      delete env[name];\n    }\n\n    // console.log(env);\n\n    const list = Expr.extras.toposort(undefined, env).list;\n\n    const detour = new Map();\n    if (Object.keys(needDetour).length) {\n      // replace aliases with their detoured counterparts.\n      // we have to go recursive, otherwise an unrelated alias may be expanded to its impl\n      // and name infos will be erased\n      const rework = expr => {\n        return expr.traverse(e => {\n          if (!(e instanceof Alias))\n            return null; // continue\n          const newAlias = detour.get(e);\n          if (newAlias)\n            return newAlias;\n          return new Alias(e.name, rework(e.impl));\n        }) ?? expr;\n      };\n\n      for (let i = 0; i < list.length; i++) {\n        // upon processing list[i], only terms declared before it may be detoured\n        list[i] = rework(list[i], detour);\n        detour.set(needDetour[list[i].name], list[i]);\n        env[list[i].name] = list[i];\n        console.log(`list[${i}] = ${list[i].name}=${list[i].impl};`);\n      }\n      console.log('detour:', detour);\n    }\n\n    // console.log(res);\n    const out = list.map(e => needDetour[e]\n      ? e.name + '=' + needDetour[e].name + '=' + e.impl.format({ inventory: env })\n      : e.name + '=' + e.impl.format({ inventory: env })\n    );\n\n    for (const [name, temp] of detour)\n      out.push(name + '=' + temp, temp + '=');\n\n    return out;\n  }\n\n  /**\n   *\n   * @param {string} source\n   * @param {Object} [options]\n   * @param {{[keys: string]: Expr}} [options.env]\n   * @param {any} [options.scope]\n   * @param {boolean} [options.numbers]\n   * @param {boolean} [options.lambdas]\n   * @param {string} [options.allow]\n   * @return {Expr}\n   */\n  parse (source, options = {}) {\n    if (typeof source !== 'string')\n      throw new Error('parse: source must be a string, got ' + typeof source);\n\n    const lines = source.replace(/\\/\\/[^\\n]*$/gm, ' ')\n      .replace(/\\/\\*.*?\\*\\//gs, ' ')\n      .trim()\n      .split(/\\s*;[\\s;]*/).filter( s => s.match(/\\S/));\n\n    const jar = { ...options.env };\n\n    let expr = new Empty();\n    for (const item of lines) {\n      if (expr instanceof Alias)\n        expr.outdated = true;\n\n      const def = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\\s*=(.*)$/s);\n      if (def && def[2] === '')\n        expr = new FreeVar(def[1], options.scope ?? SKI);\n      else\n        expr = this.parseLine(item, jar, options);\n\n      if (def) {\n        if (jar[def[1]] !== undefined)\n          throw new Error('Attempt to redefine a known term: ' + def[1]);\n        jar[def[1]] = expr;\n      }\n\n      // console.log('parsed line:', item, '; got:', expr,'; jar now: ', jar);\n    }\n\n    expr.context = {\n      env:    { ...this.getTerms(), ...jar }, // also contains pre-parsed terms\n      scope:  options.scope,\n      src:    source,\n      parser: this,\n    };\n    return expr;\n  }\n\n  /**\n   *\n   * @param {String} source S(KI)I\n   * @param {{[keys: string]: Expr}} env\n   * @param {Object} [options]\n   * @param {{[keys: string]: Expr}} [options.env] - unused, see 'env' argument\n   * @param {any} [options.scope]\n   * @param {boolean} [options.numbers]\n   * @param {boolean} [options.lambdas]\n   * @param {string} [options.allow]\n   * @return {Expr} parsed expression\n   */\n  parseLine (source, env = {}, options = {}) {\n    const aliased = source.match(/^\\s*([A-Z]|[a-z][a-z_0-9]*)\\s*=\\s*(.*)$/s);\n    if (aliased)\n      return new Alias(aliased[1], this.parseLine(aliased[2], env, options));\n\n    const opt = {\n      numbers: options.numbers ?? this.hasNumbers,\n      lambdas: options.lambdas ?? this.hasLambdas,\n      allow:   restrict(this.allow, options.allow),\n    };\n    // make sure '+' usage is in sync with numerals\n    opt.numbers ? opt.allow.add('+') : opt.allow.delete('+');\n\n    const tokens = combChars.split(source);\n\n    const empty = new Empty();\n    /** @type {Expr[]} */\n    const stack = [empty];\n    const context = options.scope || SKI; // default is global unbound vars\n\n    // TODO each token should carry along its position in source\n    for (const c of tokens) {\n      // console.log(\"parseLine: found \"+c+\"; stack =\", stack.join(\", \"));\n      if (c === '(')\n        stack.push(empty);\n      else if (c === ')') {\n        if (stack.length < 2)\n          throw new Error('unbalanced input: extra closing parenthesis' + source);\n        const x = postParse(stack.pop());\n        const f = stack.pop();\n        stack.push(f.apply(x));\n      } else if (c === '->') {\n        if (!opt.lambdas)\n          throw new Error('Lambdas not supported, allow them explicitly');\n        stack.push(new PartialLambda(stack.pop(), env));\n      } else if (c.match(/^[0-9]+$/)) {\n        if (!opt.numbers)\n          throw new Error('Church numbers not supported, allow them explicitly');\n        const f = stack.pop();\n        stack.push(f.apply(new Church(c)));\n      } else {\n        const f = stack.pop();\n        if (!env[c] && this.known[c] && !opt.allow.has(c)) {\n          throw new Error('Term \\'' + c + '\\' is not in the restricted set '\n            + [...opt.allow].sort().join(' '));\n        }\n        // look in temp vars first, then in known terms, then fallback to creating free var\n        const x = env[c] ?? this.known[c] ?? (env[c] = new FreeVar(c, context));\n        stack.push(f.apply(x));\n      }\n    }\n\n    if (stack.length !== 1) {\n      throw new Error('unbalanced input: missing '\n          + (stack.length - 1) + ' closing parenthesis:' + source);\n    }\n\n    return postParse(stack.pop());\n  }\n\n  toJSON () {\n    return {\n      version:  '1.1.1', // set to incremented package.json version whenever SKI serialization changes\n      allow:    this.showRestrict('+'),\n      numbers:  this.hasNumbers,\n      lambdas:  this.hasLambdas,\n      annotate: this.annotate,\n      terms:    this.declare(),\n    }\n  }\n}\n\n/**\n *  Public static shortcuts to common functions (see also ./extras.js)\n */\n\n/**\n * @desc Create a proxy object that generates variables on demand,\n *       with names corresponding to the property accessed.\n *       Different invocations will return distinct variables,\n *       even if with the same name.\n *\n *\n * @example const {x, y, z} = SKI.vars();\n *          x.name; // 'x'\n *          x instanceof FreeVar; // true\n *          x.apply(y).apply(z); // x(y)(z)\n *\n * @return {{[key: string]: FreeVar}}\n */\n\nSKI.vars = function (context = {}) {\n  const cache = {};\n  return new Proxy({}, {\n    get: (target, name) => {\n      if (!(name in cache))\n        cache[name] = new FreeVar(name, context);\n      return cache[name];\n    }\n  });\n};\n\n/**\n * Convert a number to Church encoding\n * @param {number} n\n * @return {Church}\n */\nSKI.church = n => new Church(n);\n\n/**\n *\n * @type {{[key: string]: Native}}\n */\n\nfor (const name in native)\n  SKI[name] = native[name];\n\nSKI.classes = classes;\nSKI.native = native;\nSKI.control = Expr.control;\n\nmodule.exports = { SKI };\n", "const { SKI } = require('./parser');\nconst { Expr, FreeVar, Alias, Lambda } = SKI.classes;\n\n/**\n * @typedef {{\n *   pass: boolean,\n *   reason: string?,\n *   steps: number,\n *   start: Expr,\n *   found: Expr,\n *   expected: Expr,\n *   note: string?,\n *   args: Expr[],\n *   case: Case\n * }} CaseResult\n */\n\n/**\n * @typedef {{\n *   linear: boolean?,\n *   affine: boolean?,\n *   normal: boolean?,\n *   proper: boolean?,\n *   discard: boolean?,\n *   duplicate: boolean?,\n *   arity: number?,\n * }} Capability\n */\n\n/**\n * @typedef {\n *   [string, string]\n *   | [{max: number?}, string, string]\n *   | [{caps: Capability, max: number?}, string]\n * } TestCase\n */\n\n/**\n * @typedef {string | {name: string, fancy?: string, allow?: string, numbers?: boolean, lambdas?: boolean}} InputSpec\n */\n\n/**\n * @typedef {{\n *   pass: boolean,\n *   details: CaseResult[],\n *   expr?: Expr,\n *   input: Expr[]|string[],\n *   exception?: Error,\n *   steps: number,\n *   weight?: number\n * }} QuestResult\n */\n\nclass Quest {\n  /**\n   * @description A combinator problem with a set of test cases for the proposed solution.\n   * @param {{\n   *    input: InputSpec | InputSpec[],\n   *    cases: TestCase[],\n   *\n   *    // the rest is optional\n\n   *    allow?: string,\n   *    numbers?: boolean,\n   *    env?: string[],\n   *    engine?: SKI,\n   *    engineFull?: SKI,\n   *\n   *    // metadata, also any fields not listed here will go to quest.meta.???\n   *    id?: string|number,\n   *    name?: string,\n   *    intro?: string|string[], // multiple strings will be concatenated with spaces\n   * }} options\n   *\n   * @example const quest = new Quest({\n   *    input: 'identity',\n   *    cases: [\n   *      ['identity x', 'x'],\n   *    ],\n   *    allow: 'SK',\n   *    intro: 'Find a combinator that behaves like the identity function.',\n   * });\n   * quest.check('S K K'); // { pass: true, details: [...], ... }\n   * quest.check('K S');   // { pass: false, details: [...], ... }\n   * quest.check('K x');   // fail! internal variable x is not equal to free variable x,\n   *                       //     despite having the same name.\n   * quest.check('I');     // fail! I not in the allowed list.\n   */\n  constructor (options = {}) {\n    const { input, cases, allow, numbers, lambdas, engine, engineFull, ...meta } = options;\n    const env = options.env ?? options.vars; // backwards compatibility\n\n    //\n    this.engine = engine ?? new SKI();\n    this.engineFull = engineFull ?? new SKI();\n    this.restrict = { allow, numbers: numbers ?? false, lambdas: lambdas ?? false };\n    this.env = {};\n\n    const jar = {};\n\n    // option.env is a list of expressions.\n    // we suck all free variables + all term declarations from there into this.env\n    // to feed it later to every case's parser.\n    for (const term of env ?? []) {\n      const expr = this.engineFull.parse(term, { env: jar, scope: this });\n      if (expr instanceof SKI.classes.Alias)\n        this.env[expr.name] = new Alias(expr.name, expr.impl, { terminal: true, canonize: false });\n        // Canonized aliases won't expand with insufficient arguments,\n        // causing correct solutions to fail, so alas...\n      else if (expr instanceof SKI.classes.FreeVar)\n        this.env[expr.name] = expr;\n      else\n        throw new Error('Unsupported given variable type: ' + term);\n    }\n\n    this.input = [];\n    for (const term of Array.isArray(input) ? input : [input])\n      this.addInput(term);\n    if (!this.input.length)\n      throw new Error('Quest needs at least one input placeholder');\n\n    this.envFull = { ...this.env, ...jar };\n    for (const term of this.input) {\n      if (term.name in this.envFull)\n        throw new Error('input placeholder name is duplicated or clashes with env: ' + term.name);\n      this.envFull[term.name] = term.placeholder;\n    }\n\n    // NOTE meta is a local variable, can mutate\n    // NOTE title/descr are old name/intro respectively, kept for backwards compatibility\n    this.cases = [];\n    this.name = meta.name ?? meta.title;\n    meta.intro = list2str(meta.intro ?? meta.descr);\n    this.intro = meta.intro;\n    this.id = meta.id;\n    this.meta = meta;\n\n    for (const c of cases ?? [])\n      this.add(...c);\n  }\n\n  /**\n   *   Display allowed terms based on what engine thinks of this.env + this.restrict.allow\n   *   @return {string}\n   */\n  allowed () {\n    const allow = this.restrict.allow ?? '';\n    const env  = Object.keys(this.env).sort();\n    // In case vars are present and restrictions aren't, don't clutter the output with all the known terms\n    return allow\n      ? this.engine.showRestrict(allow + '+' + env.join(' '))\n      : env.map( s => '+' + s).join(' ');\n  }\n\n  addInput (term) {\n    if (typeof term !== 'object')\n      term = { name: term };\n    if (typeof term.name !== 'string')\n      throw new Error(\"quest 'input' field must be a string or a {name: string, ...} object\");\n\n    term.placeholder = new SKI.classes.FreeVar(term.name);\n    // TODO more checks\n    this.input.push(term);\n  }\n\n  /**\n   *\n   * @param {{} | string} opt\n   * @param {string} terms\n   * @return {Quest}\n   */\n  add (opt, ...terms) {\n    if (typeof opt === 'string') {\n      terms.unshift(opt);\n      opt = {};\n    } else\n      opt = { ...opt };\n\n    opt.engine = opt.engine  ?? this.engineFull;\n    opt.env = opt.env ?? this.envFull;\n\n    const input = this.input.map( t => t.placeholder );\n    this.cases.push(\n      opt.caps\n        ? new PropertyCase(input, opt, terms)\n        : new ExprCase(input, opt, terms)\n    );\n    return this;\n  }\n\n  /**\n   * @description Statefully parse a list of strings into expressions or fancy aliases thereof.\n   * @param {string[]} input\n   * @return {{terms: Expr[], weight: number}}\n   */\n  prepare (...input) {\n    if (input.length !== this.input.length)\n      throw new Error('Solutions provided ' + input.length + ' terms where ' + this.input.length + ' are expected');\n\n    let weight = 0;\n    const prepared = [];\n    const jar = { ...this.env };\n    for (let i = 0; i < input.length; i++) {\n      const spec = this.input[i];\n      const impl = this.engine.parse(input[i], {\n        env:     jar,\n        allow:   spec.allow ?? this.restrict.allow,\n        numbers: spec.numbers ?? this.restrict.numbers,\n        lambdas: spec.lambdas ?? this.restrict.lambdas,\n      });\n      weight += impl.weight();\n      const expr = impl instanceof FreeVar\n        ? impl\n        : new Alias(spec.fancy ?? spec.name, impl, { terminal: true, canonize: false });\n      jar[spec.name] = expr;\n      prepared.push(expr);\n    }\n    return {\n      prepared,\n      weight,\n    };\n  }\n\n  /**\n   *\n   * @param {string} input\n   * @return {QuestResult}\n   */\n  check (...input) {\n    try {\n      const { prepared, weight } = this.prepare(...input);\n      const details = this.cases.map( c => c.check(...prepared) );\n      const pass = details.reduce((acc, val) => acc && val.pass, true);\n      const steps = details.reduce((acc, val) => acc + val.steps, 0);\n      return {\n        expr:  prepared[0],\n        input: prepared,\n        pass,\n        steps,\n        details,\n        weight,\n      };\n    } catch (e) {\n      return { pass: false, details: [], exception: e, steps: 0, input };\n    }\n  }\n\n  /**\n     *\n     * @return {TestCase[]}\n     */\n  show () {\n    return [...this.cases];\n  }\n}\n\nclass Case {\n  /**\n   * @param {FreeVar[]} input\n   * @param {{\n   *   max?: number,\n   *   note?: string,\n   *   env?: {[key:string]: Expr},\n   *   engine: SKI\n   * }} options\n   */\n  constructor (input, options) {\n    this.max = options.max ?? 1000;\n    this.note = options.note;\n    this.env = { ...(options.env ?? {}) }; // note: env already contains input placeholders\n    this.input = input;\n    this.engine = options.engine;\n  }\n\n  parse (src) {\n    return new Subst(this.engine.parse(src, { env: this.env, scope: this }), this.input);\n  }\n\n  /**\n   * @param {Expr} expr\n   * @return {CaseResult}\n   */\n  check ( ...expr ) {\n    throw new Error('not implemented');\n  }\n}\n\nclass ExprCase extends Case {\n  /**\n   * @param {FreeVar[]} input\n   * @param {{\n   *    max: number?,\n   *    note: string?,\n   *    env: {string: Expr}?,\n   *    engine: SKI?\n   * }} options\n   * @param {[e1: string, e2: string]} terms\n   */\n  constructor (input, options, terms) {\n    if (terms.length !== 2)\n      throw new Error('Case accepts exactly 2 strings');\n\n    super(input, options);\n\n    [this.e1, this.e2] = terms.map( s => this.parse(s) );\n  }\n\n  check (...args) {\n    const e1 = this.e1.apply(args);\n    const r1 = e1.run({ max: this.max });\n    const e2 = this.e2.apply(args);\n    const r2 = e2.run({ max: this.max });\n\n    let reason = null;\n    if (!r1.final || !r2.final)\n      reason = 'failed to reach normal form in ' + this.max + ' steps';\n    else\n      reason = r1.expr.diff(r2.expr);\n\n    return {\n      pass:     !reason,\n      reason,\n      steps:    r1.steps,\n      start:    e1,\n      found:    r1.expr,\n      expected: r2.expr,\n      note:     this.note,\n      args,\n      case:     this,\n    };\n  }\n}\n\nconst knownCaps = {\n  normal:    true,\n  proper:    true,\n  discard:   true,\n  duplicate: true,\n  linear:    true,\n  affine:    true,\n  arity:     true,\n}\n\nclass PropertyCase extends Case {\n  // test that an expression uses all of its inputs exactly once\n  constructor (input, options, terms) {\n    super(input, options);\n    if (terms.length > 1)\n      throw new Error('PropertyCase accepts exactly 1 string');\n    if (!options.caps || typeof options.caps !== 'object' || !Object.keys(options.caps).length)\n      throw new Error('PropertyCase requires a caps object with at least one capability');\n    const unknown = Object.keys(options.caps).filter( c => !knownCaps[c] );\n    if (unknown.length)\n      throw new Error('PropertyCase: don\\'t know how to test these capabilities: ' + unknown.join(', '));\n\n    this.expr = this.parse(terms[0]);\n    this.caps = options.caps;\n\n    if (this.caps.linear) {\n      delete this.caps.linear;\n      this.caps.duplicate = false;\n      this.caps.discard = false;\n      this.caps.normal = true;\n    }\n\n    if (this.caps.affine) {\n      delete this.caps.affine;\n      this.caps.normal = true;\n      this.caps.duplicate = false;\n    }\n  }\n\n  check (...expr) {\n    const start = this.expr.apply(expr);\n    const r = start.run({ max: this.max });\n    const guess = r.expr.infer({ max: this.max });\n\n    const reason = [];\n    for (const cap in this.caps) {\n      if (guess[cap] !== this.caps[cap])\n        reason.push('expected property ' + cap + ' to be ' + this.caps[cap] + ', found ' + guess[cap]);\n    }\n\n    return {\n      pass:   !reason.length,\n      reason: reason ? reason.join('\\n') : null,\n      steps:  r.steps,\n      start,\n      found:  r.expr,\n      case:   this,\n      note:   this.note,\n      args:   expr,\n    };\n  }\n}\n\nclass Subst {\n  /**\n   * @descr A placeholder object with exactly n free variables to be substituted later.\n   * @param {Expr} expr\n   * @param {FreeVar[]} env\n   */\n  constructor (expr, env) {\n    this.expr = expr;\n    this.env = env;\n  }\n\n  apply (list) {\n    if (list.length !== this.env.length)\n      throw new Error('Subst: expected ' + this.env.length + ' terms, got ' + list.length);\n\n    let expr = this.expr;\n    for (let i = 0; i < this.env.length; i++)\n      expr = expr.subst(this.env[i], list[i]) ?? expr;\n\n    return expr;\n  }\n}\n\n/**\n * @desc Concatenate long strings represented as arrays, or just pass along if already string or undefined.\n * @param {string|Array<string>|undefined} str\n * @returns {string|undefined}\n */\nfunction list2str (str) {\n  if (str === undefined || typeof str === 'string')\n    return str;\n  return Array.isArray(str) ? str.join(' ') : '' + str;\n}\n\nmodule.exports = { Quest };\n", "'use strict';\n\nconst { Expr, Alias, FreeVar } = require('./expr')\n\n/**\n * @desc  Extra utilities that do not belong in the core.\n */\n\n/**\n * @experimental\n * @desc  Look for an expression that matches the predicate,\n *        starting with the seed and applying the terms to one another.\n *\n *        A predicate returning 0 (or nothing) means \"keep looking\",\n *        a positive number stands for \"found\",\n *        and a negative means \"discard this term from further applications\".\n *\n *        The order of search is from shortest to longest expressions.\n *\n * @param {Expr[]} seed\n * @param {object} options\n * @param {number} [options.depth] - maximum generation to search for\n * @param {number} [options.tries] - maximum number of tries before giving up\n * @param {boolean} [options.infer] - whether to call infer(), default true.\n * @param {number} [options.maxArgs] - arguments in infer()\n * @param {number} [options.max] - step limit in infer()\n * @param {boolean} [options.noskip] - prevents skipping equivalent terms. Always true if infer is false.\n * @param {boolean} [retain] - if true. also add the whole cache to returned value\n * @param {({gen: number, total: number, probed: number, step: boolean}) => void} [options.progress]\n * @param {number} [options.progressInterval] - minimum number of tries between calls to options.progress, default 1000.\n * @param {(e: Expr, props: {}) => number?} predicate\n * @return {{expr?: Expr, total: number, probed: number, gen: number, cache?: Expr[][]}}\n */\nfunction search (seed, options, predicate) {\n  const {\n    depth = 16,\n    infer = true,\n    progressInterval = 1000,\n  } = options;\n  const hasSeen = infer && !options.noskip;\n\n  // cache[i] = ith generation, 0 is empty\n  const cache = [[]];\n  let total = 0;\n  let probed = 0;\n  const seen = {};\n\n  const maybeProbe = term => {\n    total++;\n    const props = infer ? term.infer({ max: options.max, maxArgs: options.maxArgs }) : null;\n    if (hasSeen && props.expr) {\n      if (seen[props.expr])\n        return { res: -1 };\n      seen[props.expr] = true;\n    }\n    probed++;\n    const res = predicate(term, props);\n    return { res, props };\n  };\n\n  // sieve through the seed\n  for (const term of seed) {\n    const { res } = maybeProbe(term);\n    if (res > 0)\n      return { expr: term, total, probed, gen: 1 };\n    else if (res < 0)\n      continue;\n\n    cache[0].push(term);\n  }\n\n  let lastProgress;\n\n  for (let gen = 1; gen < depth; gen++) {\n    if (options.progress) {\n      options.progress({ gen, total, probed, step: true });\n      lastProgress = total;\n    }\n    for (let i = 0; i < gen; i++) {\n      for (const a of cache[gen - i - 1] || []) {\n        for (const b of cache[i] || []) {\n          if (total >= options.tries)\n            return { total, probed, gen, ...(options.retain ? { cache } : {}) };\n          if (options.progress && total - lastProgress >= progressInterval) {\n            options.progress({ gen, total, probed, step: false });\n            lastProgress = total;\n          }\n          const term = a.apply(b);\n          const { res, props } = maybeProbe(term);\n\n          if (res > 0)\n            return { expr: term, total, probed, gen, ...(options.retain ? { cache } : {}) };\n          else if (res < 0)\n            continue;\n\n          // if the term is not reducible, it is more likely to be a dead end, so we push it further away\n          const offset = infer\n            ? ((props.expr ? 0 : 3) + (props.dup ? 1 : 0) + (props.proper ? 0 : 1))\n            : 0;\n          if (!cache[gen + offset])\n            cache[gen + offset] = [];\n          cache[gen + offset].push(term);\n        }\n      }\n    }\n  }\n\n  return { total, probed, gen: depth, ...(options.retain ? { cache } : {}) };\n}\n\n/**\n * @desc Recursively replace all instances of Expr in a data structure with\n *       respective string representation using the format() options.\n *       Objects of other types and primitive values are eft as is.\n *\n *       May be useful for debugging or diagnostic output.\n *\n * @experimental\n *\n * @param {any} obj\n * @param {object} [options] - see Expr.format()\n * @returns {any}\n */\nfunction deepFormat (obj, options = {}) {\n  if (obj instanceof Expr)\n    return obj.format(options);\n  if (Array.isArray(obj))\n    return obj.map(deepFormat);\n  if (typeof obj !== 'object' || obj === null || obj.constructor !== Object)\n    return obj;\n\n  // default = plain object\n  const out = {};\n  for (const key in obj)\n    out[key] = deepFormat(obj[key]);\n\n  return out;\n}\n\nfunction declare (expr, env) {\n  const res = Expr.extras.toposort([expr], env);\n\n  return res.list.map(s => {\n    if (s instanceof Alias)\n      return s.name + '=' + s.impl.format({ inventory: res.env });\n    if (s instanceof FreeVar)\n      return s.name + '=';\n    return s.format({ inventory: res.env });\n  }).join('; ');\n}\n\nmodule.exports = { search, deepFormat, declare };\n", "const { SKI } = require('./src/parser');\nconst { Quest } = require('./src/quest');\nconst extras = require('./src/extras');\n\nSKI.Quest = Quest;\nSKI.extras = { ...extras, ...SKI.classes.Expr.extras };\n\n// SKI_REPL=1 node -r ./index.js\nif (typeof process === 'object' && process.env.SKI_REPL && typeof global !== 'undefined') {\n  global.SKI = SKI;\n  console.log('SKI_REPL activated, try `new SKI();`');\n}\n\n// we're in a browser\nif (typeof window !== 'undefined')\n  window.SKI = SKI;\n\nmodule.exports = { SKI, Quest }; // TODO remove Quest on next breaking release, it's in SKI already!\n"],
-  "mappings": "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",
+  "sourcesContent": ["class Tokenizer {\n  /**\n   * @desc Create a tokenizer that splits strings into tokens according to the given terms.\n   * The terms are interpreted as regular expressions, and are sorted by length\n   * to ensure that longer matches are preferred over shorter ones.\n   * @param {...string|RegExp} terms\n   */\n  constructor (...terms) {\n    const src = '$|(\\\\s+)|' + terms\n      .map(s => '(?:' + s + ')')\n      .sort((a, b) => b.length - a.length)\n      .join('|');\n    this.rex = new RegExp(src, 'gys');\n  }\n\n  /**\n   * @desc Split the given string into tokens according to the terms specified in the constructor.\n   * @param {string} str\n   * @return {string[]}\n   */\n  split (str) {\n    this.rex.lastIndex = 0;\n    const list = [...str.matchAll(this.rex)];\n\n    // did we parse everything?\n    const eol = list.pop();\n    const last = eol?.index ?? 0;\n\n    if (last !== str.length) {\n      throw new Error('Unknown tokens at pos ' + last + '/' + str.length\n                + ' starting with ' + str.substring(last));\n    }\n\n    // skip whitespace\n    return list.filter(x => x[1] === undefined).map(x => x[0]);\n  }\n}\n\nconst tokRestrict = new Tokenizer('[-=+]', '[A-Z]', '\\\\b[a-z_][a-z_0-9]*\\\\b');\n\n/**\n * @desc Add ot remove tokens from a set according to a spec string.\n * The spec string is a sequence of tokens, with each group optionally prefixed\n * by one of the operators '=', '+', or '-'.\n * The '=' operator resets the set to contain only the following token(s).\n * @param {Set<string>} set\n * @param {string} [spec]\n * @returns {Set<string>}\n */\nfunction restrict (set, spec) {\n  if (!spec)\n    return set;\n  let out = new Set([...set]);\n  const act = {\n    '=': sym => { out = new Set([sym]); mode = '+'; },\n    '+': sym => { out.add(sym); },\n    '-': sym => { out.delete(sym); },\n  };\n\n  let mode = '=';\n  for (const sym of tokRestrict.split(spec)) {\n    if (act[sym])\n      mode = sym;\n    else\n      act[mode](sym);\n  }\n  return out;\n}\n\nclass TraverseControl {\n  /**\n   * @desc A wrapper for values returned by fold/traverse callbacks\n   *       which instructs the traversal to alter its behavior while\n   *       retaining the value in question.\n   *\n   *       This class is instantiated internally be `SKI.control.*` functions,\n   *       and is not intended to be used directly by client code.\n   *\n   * @template T\n   * @param {T} value\n   * @param {function(T): TraverseControl<T>} decoration\n   */\n  constructor (value, decoration) {\n    this.value = value;\n    this.decoration = decoration;\n  }\n}\n\n/**\n * @private\n * @template T\n * @param {T|TraverseControl<T>|null} value\n * @returns {[T?, function|undefined]}\n */\nfunction unwrap (value) {\n  // `?? undefined` so that null is not 'an object'\n  if (value instanceof TraverseControl)\n    return [value.value ?? undefined, value.decoration];\n  return [value ?? undefined, undefined];\n}\n\n/**\n * @desc Prepare a self-referencing wrapper function for use as a fold/traverse control decorator.\n *\n *       If `fun` is created by `prepareWrapper`, then\n *       unwrap(fun(x)) will always return exactly [x, fun], and the second value can be checked with ===.\n *\n *       An optional label can be provided for debugging purposes.\n *\n * @private\n * @template T\n * @param {string} [label]\n * @returns {function(T): TraverseControl<T>}\n */\nfunction prepareWrapper (label) {\n  const fun = value => new TraverseControl(value, fun);\n  fun.label = label;\n  fun.toString = () => 'TraverseControl::' + label;\n  return fun;\n}\n\nmodule.exports = { Tokenizer, restrict, unwrap, prepareWrapper };\n", "'use strict';\n\nconst { unwrap, prepareWrapper } = require('./internal');\n\nconst DEFAULTS = {\n  max:     1000,\n  maxArgs: 32,\n};\n\n/**\n * @template T\n * @typedef {T | TraverseControl<T> | null} TraverseValue\n */\n/**\n * @desc Control primitives for fold() and traverse() methods.\n * @template T\n * @type {{[name: string]: function(T): TraverseControl<T>}}\n */\nconst control = {\n  descend: prepareWrapper('descend'),\n  prune:   prepareWrapper('prune'),\n  redo:    prepareWrapper('redo'),\n  stop:    prepareWrapper('stop'),\n};\n\n/**\n * @typedef {Expr | function(Expr): Partial} Partial\n */\n\nclass Expr {\n  /**\n   *  @descr A combinatory logic expression.\n   *\n   *  Applications, variables, and other terms like combinators per se\n   *  are subclasses of this class.\n   *\n   *  @abstract\n   *  @property {{\n   *    scope?: any,\n   *    env?: { [key: string]: Expr },\n   *    src?: string,\n   *    parser: object,\n   *  }} [context]\n   */\n  constructor () {\n    if (new.target === Expr)\n      throw new Error('Attempt to instantiate abstract class Expr');\n  }\n\n  /**\n   * @desc apply self to zero or more terms and return the resulting term,\n   * without performing any calculations whatsoever\n   * @param {Expr} args\n   * @return {Expr}\n   */\n  apply (...args) {\n    let expr = this;\n    for (const arg of args)\n      expr = new App(expr, arg);\n    return expr;\n  }\n\n  /**\n   * @desc Replace all aliases in the expression with their definitions, recursively.\n   * @return {Expr}\n   */\n  expand () {\n    return this.traverse(e => {\n      if (e instanceof Alias)\n        return e.impl.expand();\n    }) ?? this;\n  }\n\n  /**\n   * @desc Returns true if the expression contains only free variables and applications, false otherwise.\n   * @returns {boolean}\n   */\n  freeOnly () {\n    return !this.any(e => !(e instanceof FreeVar || e instanceof App));\n  }\n\n  /**\n   * @desc Traverse the expression tree, applying change() to each node.\n   *       If change() returns an Expr, the node is replaced with that value.\n   *       Otherwise, the node is descended further (if applicable)\n   *       or left unchanged.\n   *\n   *       The traversal order is leftmost-outermost (LO), i.e. the same order as reduction steps are taken.\n   *\n   *       Returns null if no changes were made, or the new expression otherwise.\n   *\n   * @param {(e:Expr) => (Expr|null)} change\n   * @returns {Expr|null}\n   */\n  traverse (change) {\n    return change(this);\n  }\n\n  /**\n   * @desc Returns true if predicate() is true for any subterm of the expression, false otherwise.\n   *\n   * @param {(e: Expr) => boolean} predicate\n   * @returns {boolean}\n   */\n  any (predicate) {\n    return predicate(this);\n  }\n\n  /**\n   * @desc Fold the expression into a single value by recursively applying combine() to its subterms.\n   *       Nodes are traversed in leftmost-outermost order, i.e. the same order as reduction steps are taken.\n   *\n   * null or undefined return value from combine() means \"keep current value and descend further\".\n   *\n   * SKI.control provides primitives to control the folding flow:\n   *  - SKI.control.prune(value) means \"use value and don't descend further into this branch\";\n   *  - SKI.control.stop(value) means \"stop folding immediately and return value\".\n   *  - SKI.control.descend(value) is the default behavior, meaning \"use value and descend further\".\n   *\n   * This method is experimental and may change in the future.\n   *\n   * @experimental\n   * @template T\n   * @param {T} initial\n   * @param {(acc: T, expr: Expr) => TraverseValue<T>} combine\n   * @returns {T}\n   */\n  fold (initial, combine) {\n    const [value, _] = unwrap(this._fold(initial, combine));\n    return value ?? initial;\n  }\n\n  /**\n   * @template T\n   * @param {T} initial\n   * @param {(acc: T, expr: Expr) => TraverseValue<T>} combine\n   * @returns {TraverseValue<T>}\n   * @private\n   */\n  _fold (initial, combine) {\n    return combine(initial, this);\n  }\n\n  /**\n   * @desc rough estimate of the term's complexity\n   * @return {number}\n   */\n  weight () {\n    return 1;\n  }\n\n  /**\n   * @desc Try to empirically find an equivalent lambda term for the expression,\n   *       returning also the term's arity and some other properties.\n   *\n   *       This is used internally when declaring a Native / Alias term,\n   *       unless {canonize: false} is used.\n   *\n   *       As of current it only recognizes terms that have a normal form,\n   *       perhaps after adding some variables. This may change in the future.\n   *\n   *       Use toLambda() if you want to get a lambda term in any case.\n   *\n   * @param {{max?: number, maxArgs?: number}} options\n   * @return {{\n   *    normal: boolean,\n   *    steps: number,\n   *    expr?: Expr,\n   *    arity?: number,\n   *    proper?: boolean,\n   *    discard?: boolean,\n   *    duplicate?: boolean,\n   *    skip?: Set<number>,\n   *    dup?: Set<number>,\n   * }}\n   */\n  infer (options = {}) {\n    const max = options.max ?? DEFAULTS.max;\n    const maxArgs = options.maxArgs ?? DEFAULTS.maxArgs;\n    const out = this._infer({ max, maxArgs, index: 0 });\n    return out;\n  }\n\n  /**\n   *\n   * @param {{max: number, maxArgs: number, index: number}} options\n   * @param {FreeVar[]} preArgs\n   * @param {number} steps\n   * @returns {{\n   *    normal: boolean,\n   *    steps: number,\n   *    expr?: Expr,\n   *    arity?: number,\n   *    skip?: Set<number>,\n   *    dup?: Set<number>,\n   *    duplicate, discard, proper: boolean\n   * }\n   * @private\n   */\n  _infer (options, preArgs = [], steps = 0) {\n    if (preArgs.length > options.maxArgs || steps > options.max)\n      return { normal: false, steps };\n\n    // happy case\n    if (this.freeOnly()) {\n      return {\n        normal: true,\n        steps,\n        ...maybeLambda(preArgs, this),\n      };\n    }\n\n    // try reaching the normal form\n    const next = this.run({ max: (options.max - steps) / 3 });\n    steps += next.steps;\n    if (!next.final)\n      return { normal: false, steps };\n\n    // normal form != this, redo exercise\n    if (next.steps !== 0)\n      return next.expr._infer(options, preArgs, steps);\n\n    // adding more args won't help, bail out\n    // if we're an App, the App's _infer will take care of further args\n    if (this.unroll()[0] instanceof FreeVar)\n      return { normal: false, steps };\n\n    // try adding more arguments, maybe we'll get a normal form then\n    const push = nthvar(preArgs.length + options.index);\n    return this.apply(push)._infer(options, [...preArgs, push], steps);\n  }\n\n  /**\n   * @desc Expand an expression into a list of terms\n   * that give the initial expression when applied from left to right:\n   * ((a, b), (c, d)) => [a, b, (c, d)]\n   *\n   * This can be thought of as an opposite of apply:\n   * fun.apply(...arg).unroll() is exactly [fun, ...args]\n   * (even if ...arg is in fact empty).\n   *\n   * @returns {Expr[]}\n   */\n  unroll () {\n    // currently only used by infer() but may be useful\n    // to convert binary App trees to n-ary or smth\n    return [this];\n  }\n\n  /**\n   * @desc Returns a series of lambda terms equivalent to the given expression,\n   *       up to the provided computation steps limit,\n   *       in decreasing weight order.\n   *\n   *       Unlike infer(), this method will always return something,\n   *       even if the expression has no normal form.\n   *\n   *       See also Expr.walk() and Expr.toSKI().\n   *\n   * @param {{\n   *   max?: number,\n   *   maxArgs?: number,\n   *   varGen?: function(void): FreeVar,\n   *   steps?: number,\n   *   html?: boolean,\n   *   latin?: number,\n   * }} options\n   * @param {number} [maxWeight] - maximum allowed weight of terms in the sequence\n   * @return {IterableIterator<{expr: Expr, steps?: number, comment?: string}>}\n   */\n  * toLambda (options = {}) {\n    const expr = this.traverse(e => {\n      if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)\n        return null; // no change\n      const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });\n      if (!guess.normal)\n        throw new Error('Failed to infer an equivalent  lambda term for ' + e);\n      return guess.expr;\n    }) ?? this;\n    yield * simplifyLambda(expr, options);\n  }\n\n  /**\n   * @desc Rewrite the expression into S, K, and I combinators step by step.\n   *     Returns an iterator yielding the intermediate expressions,\n   *     along with the number of steps taken to reach them.\n   *\n   *     See also Expr.walk() and Expr.toLambda().\n   *\n   * @param {{max?: number}} [options]\n   * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}\n   */\n  * toSKI (options = {}) {\n    // TODO options.max is not actually max, it's the number of steps in one iteration\n    let steps = 0;\n    let expr = this;\n    while (true) {\n      const opt = { max: options.max ?? 1, steps: 0 };\n      const next = expr._rski(opt);\n      const final = opt.steps === 0;\n      yield { expr, steps, final };\n      if (final)\n        break;\n      expr = next;\n      steps += opt.steps;\n    }\n  }\n\n  /**\n   * @desc Internal method for toSKI, which performs one step of the conversion.\n   * @param {{max: number, steps: number}} options\n   * @returns {Expr}\n   * @private\n   */\n  _rski (options) {\n    return this;\n  }\n\n  /**\n   * Replace all instances of plug in the expression with value and return the resulting expression,\n   * or null if no changes could be made.\n   * Lambda terms and applications will never match if used as plug\n   * as they are impossible co compare without extensive computations.\n   * Typically used on variables but can also be applied to other terms, e.g. aliases.\n   * See also Expr.traverse().\n   * @param {Expr} search\n   * @param {Expr} replace\n   * @return {Expr|null}\n   */\n  subst (search, replace) {\n    return this === search ? replace : null;\n  }\n\n  /**\n   * @desc Apply term reduction rules, if any, to the given argument.\n   * A returned value of null means no reduction is possible.\n   * A returned value of Expr means the reduction is complete and the application\n   *     of this and arg can be replaced with the result.\n   * A returned value of a function means that further arguments are needed,\n   *     and can be cached for when they arrive.\n   *\n   * This method is between apply() which merely glues terms together,\n   *     and step() which reduces the whole expression.\n   *\n   * foo.invoke(bar) is what happens inside foo.apply(bar).step() before\n   *     reduction of either foo or bar is attempted.\n   *\n   * The name 'invoke' was chosen to avoid confusion with either 'apply' or 'reduce'.\n   *\n   * @param {Expr} arg\n   * @returns {Partial | null}\n   */\n  invoke (arg) {\n    return null;\n  }\n\n  /**\n   * @desc iterate one step of a calculation.\n   * @return {{expr: Expr, steps: number, changed: boolean}}\n   */\n  step () { return { expr: this, steps: 0, changed: false } }\n\n  /**\n   * @desc Run uninterrupted sequence of step() applications\n   *       until the expression is irreducible, or max number of steps is reached.\n   *       Default number of steps = 1000.\n   * @param {{max?: number, steps?: number, throw?: boolean}|Expr} [opt]\n   * @param {Expr} args\n   * @return {{expr: Expr, steps: number, final: boolean}}\n   */\n  run (opt = {}, ...args) {\n    if (opt instanceof Expr) {\n      args.unshift(opt);\n      opt = {};\n    }\n    let expr = args ? this.apply(...args) : this;\n    let steps = opt.steps ?? 0;\n    // make sure we make at least 1 step, to tell whether we've reached the normal form\n    const max = Math.max(opt.max ?? DEFAULTS.max, 1) + steps;\n    let final = false;\n    for (; steps < max; ) {\n      const next = expr.step();\n      if (!next.changed) {\n        final = true;\n        break;\n      }\n      steps += next.steps;\n      expr = next.expr;\n    }\n    if (opt.throw && !final)\n      throw new Error('Failed to compute expression in ' + max + ' steps');\n    return { final, steps, expr };\n  }\n\n  /**\n   * Execute step() while possible, yielding a brief description of events after each step.\n   * Mnemonics: like run() but slower.\n   * @param {{max?: number}} options\n   * @return {IterableIterator<{final: boolean, expr: Expr, steps: number}>}\n   */\n  * walk (options = {}) {\n    const max = options.max ?? Infinity;\n    let steps = 0;\n    let expr = this;\n    let final = false;\n\n    while (steps < max) {\n      // 1. calculate\n      // 2. yield _unchanged_ expression\n      // 3. either advance or stop\n      const next = expr.step();\n      if (!next.changed)\n        final = true;\n      yield { expr, steps, final };\n      if (final)\n        break;\n      steps += next.steps;\n      expr = next.expr;\n    }\n  }\n\n  /**\n   * @desc True is the expressions are identical, false otherwise.\n   *       Aliases are expanded.\n   *       Bound variables in lambda terms are renamed consistently.\n   *       However, no reductions are attempted.\n   *\n   *       E.g. a->b->a == x->y->x is true, but a->b->a == K is false.\n   *\n   * @param {Expr} other\n   * @return {boolean}\n   */\n  equals (other) {\n    return !this.diff(other);\n  }\n\n  /**\n   * @desc Recursively compare two expressions and return a string\n   *       describing the first point of difference.\n   *       Returns null if expressions are identical.\n   *\n   *       Aliases are expanded.\n   *       Bound variables in lambda terms are renamed consistently.\n   *       However, no reductions are attempted.\n   *\n   *       Members of the FreeVar class are considered different\n   *       even if they have the same name, unless they are the same object.\n   *       To somewhat alleviate confusion, the output will include\n   *       the internal id of the variable in square brackets.\n   *\n   * @example  \"K(S != I)\" is the result of comparing \"KS\" and \"KI\"\n   * @example  \"S(K([x[13] != x[14]]))K\"\n   *\n   * @param {Expr} other\n   * @param {boolean} [swap]  If true, the order of expressions is reversed in the output.\n   * @returns {string|null}\n   */\n  diff (other, swap = false) {\n    if (this === other)\n      return null;\n    if (other instanceof Alias)\n      return other.impl.diff(this, !swap);\n    return swap\n      ? '[' + other + ' != ' + this  + ']'\n      : '[' + this  + ' != ' + other + ']';\n  }\n\n  /**\n   * @desc Assert expression equality. Can be used in tests.\n   * @param {Expr} expected\n   * @param {string} comment\n   */\n  expect (expected, comment = '') {\n    comment = comment ? comment + ': ' : '';\n    if (!(expected instanceof Expr))\n      throw new Error(comment + 'attempt to expect a combinator to equal something else: ' + expected);\n    const diff = this.diff(expected);\n    if (!diff)\n      return; // all good\n\n    // TODO wanna use AssertionError but webpack doesn't recognize it\n    // still the below hack works for mocha-based tests.\n    const poorMans = new Error(comment + diff);\n    poorMans.expected = expected + '';\n    poorMans.actual = this + '';\n    throw poorMans;\n  }\n\n  /**\n   * @desc Returns string representation of the expression.\n   *       Same as format() without options.\n   * @return {string}\n   */\n  toString () {\n    return this.format();\n  }\n\n  /**\n   * @desc Whether the expression needs parentheses when printed.\n   * @param {boolean} [first] - whether this is the first term in a sequence\n   * @return {boolean}\n   */\n  _braced (first) {\n    return false;\n  }\n\n  /**\n   * @desc Whether the expression can be printed without a space when followed by arg.\n   * @param {Expr} arg\n   * @returns {boolean}\n   * @private\n   */\n  _unspaced (arg) {\n    return this._braced(true);\n  }\n\n  /**\n   * @desc    Stringify the expression with fancy formatting options.\n   *          Said options mostly include wrappers around various constructs in form of ['(', ')'],\n   *          as well as terse and html flags that set up the defaults.\n   *          Format without options is equivalent to toString() and can be parsed back.\n   *\n   * @param   {Object} [options]  - formatting options\n   * @param   {boolean} [options.terse]   - whether to use terse formatting (omitting unnecessary spaces and parentheses)\n   * @param   {boolean} [options.html]    - whether to default to HTML tags & entities.\n   *                                If a named term has fancyName property set, it will be used instead of name in this mode.\n   * @param   {[string, string]} [options.brackets]  - wrappers for application arguments, typically ['(', ')']\n   * @param   {[string, string]} [options.var]       - wrappers for variable names\n   *                                (will default to &lt;var&gt; and &lt;/var&gt; in html mode).\n   * @param   {[string, string, string]} [options.lambda]    - wrappers for lambda abstractions, e.g. ['&lambda;', '.', '']\n   *                                where the middle string is placed between argument and body\n   *                                default is ['', '->', ''] or ['', '-&gt;', ''] for html\n   * @param   {[string, string]} [options.around]    - wrappers around (sub-)expressions.\n   *                                individual applications will not be wrapped, i.e. (a b c) but not ((a b) c)\n   * @param   {[string, string]} [options.redex]     - wrappers around the starting term(s) that have enough arguments to be reduced\n   * @param   {Object<string, Expr>} [options.inventory]     - if given, output aliases in the set as their names\n   *                                and any other aliases as the expansion of their definitions.\n   *                                The default is a cryptic and fragile mechanism dependent on a hidden mutable property.\n   * @returns {string}\n   *\n   * @example foo.format() // equivalent to foo.toString()\n   * @example foo.format({terse: false}) // spell out all parentheses\n   * @example foo.format({html: true}) // use HTML tags and entities\n   * @example foo.format({ around: ['(', ')'], brackets: ['', ''], lambda: ['(', '->', ')'] }) // lisp style, still back-parsable\n   * @exapmle foo.format({ lambda: ['&lambda;', '.', ''] }) // pretty-print for the math department\n   * @example foo.format({ lambda: ['', '=>', ''], terse: false }) // make it javascript\n   * @example foo.format({ inventory: { T } }) // use T as a named term, expand all others\n   *\n   */\n  format (options = {}) {\n    const fallback = options.html\n      ? {\n        brackets: ['(', ')'],\n        space:    ' ',\n        var:      ['<var>', '</var>'],\n        lambda:   ['', '-&gt;', ''],\n        around:   ['', ''],\n        redex:    ['', ''],\n      }\n      : {\n        brackets: ['(', ')'],\n        space:    ' ',\n        var:      ['', ''],\n        lambda:   ['', '->', ''],\n        around:   ['', ''],\n        redex:    ['', ''],\n      }\n    return this._format({\n      terse:     options.terse    ?? true,\n      brackets:  options.brackets ?? fallback.brackets,\n      space:     options.space    ?? fallback.space,\n      var:       options.var      ?? fallback.var,\n      lambda:    options.lambda   ?? fallback.lambda,\n      around:    options.around   ?? fallback.around,\n      redex:     options.redex    ?? fallback.redex,\n      inventory: options.inventory, // TODO better name\n      html:      options.html     ?? false,\n    }, 0);\n  }\n\n  /**\n   * @desc Internal method for format(), which performs the actual formatting.\n   * @param {Object} options\n   * @param {number} nargs\n   * @returns {string}\n   * @private\n   */\n  _format (options, nargs) {\n    throw new Error( 'No _format() method defined in class ' + this.constructor.name );\n  }\n\n  /**\n   * @desc Returns a string representation of the expression tree, with indentation to show structure.\n   *\n   *       Applications are flattened to avoid excessive nesting.\n   *       Variables include ids to distinguish different instances of the same variable name.\n   *\n   *       May be useful for debugging.\n   *\n   * @returns {string}\n   *\n   * @example\n   * > console.log(ski.parse('C 5 x (x->x x)').diag())\n   * App:\n   *   Native: C\n   *   Church: 5\n   *   FreeVar: x[53]\n   *   Lambda (x[54]):\n   *     App:\n   *       FreeVar: x[54]\n   *       FreeVar: x[54]\n   */\n  diag () {\n    const rec = (e, indent) => {\n      if (e instanceof App)\n        return [indent + 'App:', ...e.unroll().flatMap(s => rec(s, indent + '  '))];\n      if (e instanceof Lambda)\n        return [`${indent}Lambda (${e.arg}[${e.arg.id}]):`, ...rec(e.impl, indent + '  ')];\n      if (e instanceof Alias)\n        return [`Alias (${e.name}):`, ...rec(e.impl, indent + '  ')];\n      if (e instanceof FreeVar)\n        return [`${indent}FreeVar: ${e.name}[${e.id}]`];\n      return [`${indent}${e.constructor.name}: ${e}`];\n    }\n\n    const out = rec(this, '');\n    return out.join('\\n');\n  }\n\n  /**\n   * @desc Convert the expression to a JSON-serializable format.\n   * @returns {string}\n   */\n  toJSON () {\n    return this.format();\n  }\n}\n\nclass App extends Expr {\n  /**\n   * @desc Application of fun() to args.\n   * Never ever use new App(fun, arg) directly, use fun.apply(...args) instead.\n   * @param {Expr} fun\n   * @param {Expr} arg\n   */\n  constructor (fun, arg) {\n    super();\n\n    this.arg = arg;\n    this.fun = fun;\n    this.final = false;\n    this.arity = this.fun.arity > 0 ? this.fun.arity - 1 : 0;\n  }\n\n  weight () {\n    return this.fun.weight() + this.arg.weight();\n  }\n\n  _infer (options, preArgs = [], steps = 0) {\n    if (preArgs.length > options.maxArgs || steps > options.max)\n      return { normal: false, steps };\n\n    /*\n     * inside and App there are 3 main possibilities:\n     * 1) The parent infer() actually is able to do the job. Then we just proxy the result.\n     * 2) Both `fun` and `arg` form good enough lambda terms. Then lump them together & return.\n     * 3) We literally have no idea, so we just pick the shortest defined term from the above.\n     */\n\n    const proxy = super._infer(options, preArgs, steps);\n    if (proxy.normal)\n      return proxy;\n    steps = proxy.steps; // reimport extra iterations\n\n    const [first, ...list] = this.unroll();\n    if (!(first instanceof FreeVar))\n      return { normal: false, steps }\n    // TODO maybe do it later\n\n    let discard = false;\n    let duplicate = false;\n    const out = [];\n    for (const term of list) {\n      const guess = term._infer({\n        ...options,\n        maxArgs: options.maxArgs - preArgs.length,\n        max:     options.max - steps,\n        index:   preArgs.length + options.index,\n      });\n      steps += guess.steps;\n      if (!guess.normal)\n        return { normal: false, steps };\n      out.push(guess.expr);\n      discard = discard || guess.discard;\n      duplicate = duplicate || guess.duplicate;\n    }\n\n    return {\n      normal: true,\n      steps,\n      ...maybeLambda(preArgs, first.apply(...out), {\n        discard,\n        duplicate,\n      }),\n    };\n  }\n\n  traverse (change) {\n    const replaced = change(this);\n    if (replaced instanceof Expr)\n      return replaced;\n\n    const fun = this.fun.traverse(change);\n    const arg = this.arg.traverse(change);\n\n    if (!fun && !arg)\n      return null; // no changes\n\n    return (fun ?? this.fun).apply(arg ?? this.arg);\n  }\n\n  any (predicate) {\n    return predicate(this) || this.fun.any(predicate) || this.arg.any(predicate);\n  }\n\n  _fold (initial, combine) {\n    const [value = initial, action = 'descend'] = unwrap(combine(initial, this));\n    if (action === control.prune)\n      return value;\n    if (action === control.stop)\n      return control.stop(value);\n    const [fValue = value, fAction = 'descend'] = unwrap(this.fun._fold(value, combine));\n    if (fAction === control.stop)\n      return control.stop(fValue);\n    const [aValue = fValue, aAction = 'descend'] = unwrap(this.arg._fold(fValue, combine));\n    if (aAction === control.stop)\n      return control.stop(aValue);\n    return aValue;\n  }\n\n  subst (search, replace) {\n    const fun = this.fun.subst(search, replace);\n    const arg = this.arg.subst(search, replace);\n\n    return (fun || arg) ? (fun ?? this.fun).apply(arg ?? this.arg) : null;\n  }\n\n  /**\n   * @return {{expr: Expr, steps: number}}\n   */\n\n  step () {\n    // normal reduction order: first try root, then at most 1 step\n    if (!this.final) {\n      // try to apply rewriting rules, if applicable, at first\n      const partial = this.fun.invoke(this.arg);\n      if (partial instanceof Expr)\n        return { expr: partial, steps: 1, changed: true };\n      else if (typeof partial === 'function')\n        this.invoke = partial; // cache for next time\n\n      // descend into the leftmost term\n      const fun = this.fun.step();\n      if (fun.changed)\n        return { expr: fun.expr.apply(this.arg), steps: fun.steps, changed: true };\n\n      // descend into arg\n      const arg = this.arg.step();\n      if (arg.changed)\n        return { expr: this.fun.apply(arg.expr), steps: arg.steps, changed: true };\n\n      // mark as irreducible\n      this.final = true; // mark as irreducible at root\n    }\n\n    return { expr: this, steps: 0, changed: false };\n  }\n\n  invoke (arg) {\n    // propagate invocation towards the root term,\n    // caching partial applications as we go\n    const partial = this.fun.invoke(this.arg);\n    if (partial instanceof Expr)\n      return partial.apply(arg);\n    else if (typeof partial === 'function') {\n      this.invoke = partial;\n      return partial(arg);\n    } else {\n      // invoke = null => we're uncomputable, cache for next time\n      this.invoke = _ => null;\n      return null;\n    }\n  }\n\n  unroll () {\n    return [...this.fun.unroll(), this.arg];\n  }\n\n  _rski (options) {\n    if (options.steps >= options.max)\n      return this;\n    return this.fun._rski(options).apply(this.arg._rski(options));\n  }\n\n  diff (other, swap = false) {\n    if (!(other instanceof App))\n      return super.diff(other, swap);\n\n    const fun = this.fun.diff(other.fun, swap);\n    if (fun)\n      return fun + '(...)';\n    const arg = this.arg.diff(other.arg, swap);\n    if (arg)\n      return this.fun + '(' + arg + ')';\n    return null;\n  }\n\n  _braced (first) {\n    return !first;\n  }\n\n  _format (options, nargs) {\n    const fun = this.fun._format(options, nargs + 1);\n    const arg = this.arg._format(options, 0);\n    const wrap = nargs ? ['', ''] : options.around;\n    // TODO ignore terse for now\n    if (options.terse && !this.arg._braced(false))\n      return wrap[0] + fun + (this.fun._unspaced(this.arg) ? '' : options.space) + arg + wrap[1];\n    else\n      return wrap[0] + fun + options.brackets[0] + arg + options.brackets[1] + wrap[1];\n  }\n\n  _unspaced (arg) {\n    return this.arg._braced(false) ? true : this.arg._unspaced(arg);\n  }\n}\n\nclass Named extends Expr {\n  /**\n   * @desc An abstract class representing a term named 'name'.\n   *\n   * @param {String} name\n   */\n  constructor (name) {\n    super();\n    if (typeof name !== 'string' || name.length === 0)\n      throw new Error('Attempt to create a named term with improper name');\n    this.name = name;\n  }\n\n  _unspaced (arg) {\n    return !!(\n      (arg instanceof Named) && (\n        (this.name.match(/^[A-Z+]$/) && arg.name.match(/^[a-z+]/i))\n          || (this.name.match(/^[a-z+]/i) && arg.name.match(/^[A-Z+]$/))\n      )\n    );\n  }\n\n  _format (options, nargs) {\n    // NOTE fancyName is not yet official and may change name or meaning\n    const name = options.html ? this.fancyName ?? this.name : this.name;\n    return this.arity > 0 && this.arity <= nargs\n      ? options.redex[0] + name + options.redex[1]\n      : name;\n  }\n}\n\nlet freeId = 0;\n\nclass FreeVar extends Named {\n  /**\n   * @desc A named variable.\n   *\n   * Given the functional nature of combinatory logic, variables are treated\n   * as functions that we don't know how to evaluate just yet.\n   *\n   * By default, two different variables even with the same name are considered different.\n   * They display it via a hidden id property.\n   *\n   * If a scope object is given, however, two variables with the same name and scope\n   * are considered identical.\n   *\n   * @param {string} name - name of the variable\n   * @param {any} scope - an object representing where the variable belongs to.\n   */\n  constructor (name, scope) {\n    super(name);\n    this.id = ++freeId;\n    // TODO temp compatibility mode\n    this.scope = scope === undefined ? this : scope;\n  }\n\n  weight () {\n    return 0;\n  }\n\n  diff (other, swap = false) {\n    if (!(other instanceof FreeVar))\n      return super.diff(other, swap);\n    if (this.name === other.name && this.scope === other.scope)\n      return null;\n    const lhs = this.name + '[' + this.id + ']';\n    const rhs = other.name + '[' + other.id + ']';\n    return swap\n      ? '[' + rhs + ' != ' + lhs + ']'\n      : '[' + lhs + ' != ' + rhs + ']';\n  }\n\n  subst (search, replace) {\n    if (search instanceof FreeVar && search.name === this.name && search.scope === this.scope)\n      return replace;\n    return null;\n  }\n\n  _format (options, nargs) {\n    const name = options.html ? this.fancyName ?? this.name : this.name;\n    return options.var[0] + name + options.var[1];\n  }\n}\n\nclass Native extends Named {\n  /**\n   * @desc A named term with a known rewriting rule.\n   *       'impl' is a function with signature Expr => Expr => ... => Expr\n   *       (see typedef Partial).\n   *       This is how S, K, I, and company are implemented.\n   *\n   *       Note that as of current something like a=>b=>b(a) is not possible,\n   *       use full form instead: a=>b=>b.apply(a).\n   *\n   * @example new Native('K', x => y => x); // constant\n   * @example new Native('Y', function(f) { return f.apply(this.apply(f)); }); // self-application\n   *\n   * @param {String} name\n   * @param {Partial} impl\n   * @param {{note?: string, arity?: number, canonize?: boolean, apply?: function(Expr):(Expr|null) }} [opt]\n   */\n  constructor (name, impl, opt = {}) {\n    super(name);\n    // setup essentials\n    this.invoke  = impl;\n\n    // TODO infer lazily (on demand, only once); app capabilities such as discard and duplicate\n    // try to bootstrap and infer some of our properties\n    const guess = (opt.canonize ?? true) ? this.infer() : { normal: false };\n\n    /** @type {number} */\n    this.arity = opt.arity || guess.arity || 1;\n    /** @type {string} */\n    this.note = opt.note ?? guess.expr?.format({ terse: true, html: true, lambda: ['', ' &mapsto; ', ''] });\n  }\n\n  _rski (options) {\n    if (this === native.I || this === native.K || this === native.S || (options.steps >= options.max))\n      return this;\n    const canon = this.infer().expr;\n    if (!canon)\n      return this;\n    options.steps++;\n    return canon._rski(options);\n  }\n}\n\n// predefined global combinator list\n// it is required by toSKI method, otherwise it could've as well be in parse.js\n/**\n * @type {{[key: string]: Native}}\n */\nconst native = {};\nfunction addNative (name, impl, opt) {\n  native[name] = new Native(name, impl, opt);\n}\n\nclass Lambda extends Expr {\n  /**\n   * @desc Lambda abstraction of arg over impl.\n   *     Upon evaluation, all occurrences of 'arg' within 'impl' will be replaced\n   *     with the provided argument.\n   *\n   * Note that 'arg' will be replaced by a localized placeholder, so the original\n   * variable can be used elsewhere without interference.\n   * Listing symbols contained in the lambda will omit such placeholder.\n   *\n   * Legacy ([FreeVar], impl) constructor is supported but deprecated.\n   * It will create a nested lambda expression.\n   *\n   * @param {FreeVar} arg\n   * @param {Expr} impl\n   */\n  constructor (arg, impl) {\n    if (Array.isArray(arg)) {\n      // check args before everything\n      if (arg.length === 0)\n        throw new Error('empty argument list in lambda constructor');\n\n      const [my, ...tail] = arg;\n      const known = new Set([my.name]);\n\n      while (tail.length > 0) {\n        const last = tail.pop();\n        if (known.has(last.name))\n          throw new Error('Duplicate free var name ' + last + ' in lambda expression');\n        known.add(last.name);\n\n        // TODO keep track of arity to speed up execution\n        impl = new Lambda(last, impl);\n      }\n      arg = my;\n    }\n\n    super();\n\n    // localize argument variable and bind it to oneself\n    const local = new FreeVar(arg.name, this);\n    this.arg = local;\n    this.impl = impl.subst(arg, local) ?? impl;\n    this.arity = 1;\n  }\n\n  weight () {\n    return this.impl.weight() + 1;\n  }\n\n  _infer (options, preArgs = [], steps = 0) {\n    if (preArgs.length > options.maxArgs)\n      return { normal: false, steps };\n\n    const push = nthvar(preArgs.length + options.index);\n    return this.invoke(push)._infer(options, [...preArgs, push], steps + 1);\n  }\n\n  invoke (arg) {\n    return this.impl.subst(this.arg, arg) ?? this.impl;\n  }\n\n  traverse (change) {\n    const replaced = change(this);\n    if (replaced instanceof Expr)\n      return replaced;\n\n    // alas no proper shielding of self.arg is possible\n    const impl = this.impl.traverse(change);\n\n    if (!impl)\n      return null; // no changes\n\n    return new Lambda(this.arg, impl);\n  }\n\n  any (predicate) {\n    return predicate(this) || this.impl.any(predicate);\n  }\n\n  _fold (initial, combine) {\n    const [value = initial, action = 'descend'] = unwrap(combine(initial, this));\n    if (action === control.prune)\n      return value;\n    if (action === control.stop)\n      return control.stop(value);\n    const [iValue, iAction] = unwrap(this.impl._fold(value, combine));\n    if (iAction === control.stop)\n      return control.stop(iValue);\n    return iValue ?? value;\n  }\n\n  subst (search, replace) {\n    if (search === this.arg)\n      return null;\n    const change = this.impl.subst(search, replace);\n    return change ? new Lambda(this.arg, change) : null;\n  }\n\n  _rski (options) {\n    const impl = this.impl._rski(options);\n    if (options.steps >= options.max)\n      return new Lambda(this.arg, impl);\n    options.steps++;\n    if (impl === this.arg)\n      return native.I;\n    if (!impl.any(e => e === this.arg))\n      return native.K.apply(impl);\n    if (impl instanceof App) {\n      const { fun, arg } = impl;\n      // try eta reduction\n      if (arg === this.arg && !fun.any(e => e === this.arg))\n        return fun._rski(options);\n      // fall back to S\n      return native.S.apply(\n        (new Lambda(this.arg, fun))._rski(options),\n        (new Lambda(this.arg, arg))._rski(options)\n      );\n    }\n    throw new Error('Don\\'t know how to convert to SKI' + this);\n  }\n\n  diff (other, swap = false) {\n    if (!(other instanceof Lambda))\n      return super.diff(other, swap);\n\n    const t = new FreeVar('t'); // TODO better placeholder name\n\n    const diff = this.invoke(t).diff(other.invoke(t), swap);\n    if (diff)\n      return '(t->' + diff + ')'; // parentheses required to avoid ambiguity\n    return null;\n  }\n\n  _format (options, nargs) {\n    return (nargs > 0 ? options.brackets[0] : '')\n      + options.lambda[0]\n      + this.arg._format(options, 0) // TODO highlight redex if nargs > 0\n      + options.lambda[1]\n      + this.impl._format(options, 0) + options.lambda[2]\n      + (nargs > 0 ? options.brackets[1] : '');\n  }\n\n  _braced (first) {\n    return true;\n  }\n}\n\nclass Church extends Native {\n  /**\n   * @desc Church numeral representing non-negative integer n:\n   *      n f x = f(f(...(f x)...)) with f applied n times.\n   * @param {number} n\n   */\n  constructor (n) {\n    const p = Number.parseInt(n);\n    if (!(p >= 0))\n      throw new Error('Church number must be a non-negative integer');\n    const name = '' + p;\n    const impl = x => y => {\n      let expr = y;\n      for (let i = p; i-- > 0; )\n        expr = x.apply(expr);\n      return expr;\n    };\n\n    super(name, impl, { arity: 2, canonize: false, note: name });\n\n    /** @type {number} */\n    this.n = p;\n    this.arity = 2;\n  }\n\n  diff (other, swap = false) {\n    if (!(other instanceof Church))\n      return super.diff(other, swap);\n    if (this.n === other.n)\n      return null;\n    return swap\n      ? '[' + other.n + ' != ' + this.n + ']'\n      : '[' + this.n + ' != ' + other.n + ']';\n  }\n\n  _unspaced (arg) {\n    return false;\n  }\n}\n\nfunction waitn (expr, n) {\n  return arg => n <= 1 ? expr.apply(arg) : waitn(expr.apply(arg), n - 1);\n}\n\nclass Alias extends Named {\n  /**\n   * @desc A named alias for an existing expression.\n   *\n   *     Upon evaluation, the alias expands into the original expression,\n   *     unless it has a known arity > 0 and is marked terminal,\n   *     in which case it waits for enough arguments before expanding.\n   *\n   *     A hidden mutable property 'outdated' is used to silently\n   *     replace the alias with its definition in all contexts.\n   *     This is used when declaring named terms in an interpreter,\n   *     to avoid confusion between old and new terms with the same name.\n   *\n   * @param {String} name\n   * @param {Expr} impl\n   * @param {{canonize?: boolean, max?: number, maxArgs?: number, note?: string, terminal?: boolean}} [options]\n   */\n  constructor (name, impl, options = {}) {\n    super(name);\n    if (!(impl instanceof Expr))\n      throw new Error('Attempt to create an alias for a non-expression: ' + impl);\n    this.impl = impl;\n\n    if (options.note)\n      this.note = options.note;\n\n    const guess = options.canonize\n      ? impl.infer({ max: options.max, maxArgs: options.maxArgs })\n      : { normal: false };\n    this.arity = (guess.proper && guess.arity) || 0;\n    this.proper = guess.proper ?? false;\n    this.terminal = options.terminal ?? this.proper;\n    this.canonical = guess.expr;\n    this.invoke = waitn(impl, this.arity);\n  }\n\n  /**\n   * @property {boolean} [outdated] - whether the alias is outdated\n   *     and should be replaced with its definition when encountered.\n   * @property {boolean} [terminal] - whether the alias should behave like a standalone term\n   *     // TODO better name?\n   * @property {boolean} [proper] - whether the alias is a proper combinator (i.e. contains no free variables or constants)\n   * @property {number} [arity] - the number of arguments the alias waits for before expanding\n   * @property {Expr} [canonical] - equivalent lambda term.\n   */\n\n  weight () {\n    return this.terminal ? 1 : this.impl.weight();\n  }\n\n  traverse (change) {\n    return change(this) ?? this.impl.traverse(change);\n  }\n\n  any (predicate) {\n    return predicate(this) || this.impl.any(predicate);\n  }\n\n  _fold (initial, combine) {\n    const [value = initial, action] = unwrap(combine(initial, this));\n    if (action === control.prune)\n      return value;\n    if (action === control.stop)\n      return control.stop(value);\n    const [iValue, iAction] = unwrap(this.impl._fold(value, combine));\n    if (iAction === control.stop)\n      return control.stop(iValue);\n    return iValue ?? value;\n  }\n\n  subst (search, replace) {\n    if (this === search)\n      return replace;\n    return this.impl.subst(search, replace);\n  }\n\n  _infer (options, preArgs = [], steps = 0) {\n    return this.impl._infer(options, preArgs, steps);\n  }\n\n  // DO NOT REMOVE TYPE or tsc chokes with\n  //       TS2527: The inferred type of 'Alias' references an inaccessible 'this' type.\n  /**\n   * @return {{expr: Expr, steps: number, changed: boolean}}\n   */\n  step () {\n    // arity known = waiting for args to expand\n    if (this.arity > 0)\n      return { expr: this, steps: 0, changed: false };\n    // expanding is a change but it takes 0 steps\n    return { expr: this.impl, steps: 0, changed: true };\n  }\n\n  diff (other, swap = false) {\n    if (this === other)\n      return null;\n    return other.diff(this.impl, !swap);\n  }\n\n  _rski (options) {\n    return this.impl._rski(options);\n  }\n\n  _braced (first) {\n    return this.outdated ? this.impl._braced(first) : false;\n  }\n\n  _format (options, nargs) {\n    const outdated = options.inventory\n      ? options.inventory[this.name] !== this\n      : this.outdated;\n    return outdated ? this.impl._format(options, nargs) : super._format(options, nargs);\n  }\n}\n\n// ----- Expr* classes end here -----\n\n// declare native combinators\naddNative('I', x => x);\naddNative('K', x => _ => x);\naddNative('S', x => y => z => x.apply(z, y.apply(z)));\naddNative('B', x => y => z => x.apply(y.apply(z)));\naddNative('C', x => y => z => x.apply(z).apply(y));\naddNative('W', x => y => x.apply(y).apply(y));\n\naddNative(\n  '+',\n  n => n instanceof Church\n    ? new Church(n.n + 1)\n    : f => x => f.apply(n.apply(f, x)),\n  {\n    note: 'Increase a Church numeral argument by 1, otherwise n => f => x => f(n f x)',\n  }\n);\n\n// utility functions dependent on Expr* classes, in alphabetical order\n\n/**\n * @private\n * @given a list of free variables, an expression, and some capabilities of the context,\n *        return either a lambda term, or the original expression if no lambda abstraction is needed,\n *        plus some metadata about the term and the context.\n *\n *        Used by infer() internally.\n * @param {FreeVar[]} args\n * @param {Expr} expr\n * @param {object} caps\n * @returns {{expr: Expr, arity?: number, skip?: Set<number>, dup?: Set<number>, duplicate?, discard?, proper: boolean}}\n */\nfunction maybeLambda (args, expr, caps = {}) {\n  const count = new Array(args.length).fill(0);\n  let proper = true;\n  expr.traverse(e => {\n    if (e instanceof FreeVar) {\n      const index = args.findIndex(a => a.name === e.name);\n      if (index >= 0) {\n        count[index]++;\n        return;\n      }\n    }\n    if (!(e instanceof App))\n      proper = false;\n  });\n\n  const skip = new Set();\n  const dup = new Set();\n  for (let i = 0; i < args.length; i++) {\n    if (count[i] === 0)\n      skip.add(i);\n    else if (count[i] > 1)\n      dup.add(i);\n  }\n\n  return {\n    expr:      args.length ? new Lambda(args, expr) : expr,\n    ...(caps.synth ? {} : { arity: args.length }),\n    ...(skip.size ? { skip } : {}),\n    ...(dup.size ? { dup } : {}),\n    duplicate: !!dup.size  || caps.duplicate || false,\n    discard:   !!skip.size || caps.discard   || false,\n    proper,\n  };\n}\n\nfunction nthvar (n) {\n  return new FreeVar('abcdefgh'[n] ?? 'x' + n);\n}\n\n/**\n * @private\n * @param {Expr} expr\n * @param {{max?: number, maxArgs?: number}} options\n * @param {number} maxWeight\n * @yields {{expr: Expr, steps?: number, comment?: string}}\n */\nfunction * simplifyLambda (expr, options = {}, state = { steps: 0 }) {\n  // expr is a lambda, free variable, or an application thereof\n  // we want to find an equivalent lambda term with less weight\n  // which we do sequentially from leaves to the root of the AST\n\n  yield { expr, steps: state.steps, comment: '(self)' };\n\n  // short-circuit\n  if (expr.freeOnly())\n    return;\n\n  let maxWeight = expr.weight();\n\n  if (expr instanceof Lambda) {\n    for (const term of simplifyLambda(expr.impl, options, state)) {\n      const candidate = new Lambda(expr.arg, term.expr);\n      if (candidate.weight() < maxWeight) {\n        maxWeight = candidate.weight();\n        yield { expr: candidate, steps: state.steps, comment: '(lambda)' + term.comment };\n      }\n    }\n  }\n\n  // fun * arg Descartes product\n  if (expr instanceof App) {\n    // try to split into fun+arg, then try canonization but exposing each step\n    let { fun, arg } = expr;\n\n    for (const term of simplifyLambda(fun, options, state)) {\n      const candidate = term.expr.apply(arg);\n      if (candidate.weight() < maxWeight) {\n        maxWeight = candidate.weight();\n        fun = term.expr;\n        yield { expr: candidate, steps: state.steps, comment: '(fun)' + term.comment };\n      }\n    }\n\n    for (const term of simplifyLambda(arg, options, state)) {\n      const candidate = fun.apply(term.expr);\n      if (candidate.weight() < maxWeight) {\n        maxWeight = candidate.weight();\n        yield { expr: candidate, steps: state.steps, comment: '(arg)' + term.comment };\n      }\n    }\n  }\n\n  const canon = expr.infer({ max: options.max, maxArgs: options.maxArgs });\n  state.steps += canon.steps;\n  if (canon.expr && canon.expr.weight() < maxWeight)\n    yield { expr: canon.expr, steps: state.steps, comment: '(canonical)' };\n}\n\n/**\n * @desc  Sort a list in such a way that dependent terms come after the (named) terms they depend on.\n *        If env is given, only terms listed there are taken into account.\n *        If env is omitted, it will be implied from the list.\n *        If list is omitted, it will default to values of env.\n *        If just one term is given instead of a list, it will be coerced into a list.\n *\n *        No terms outside env + list may ever appear in the result.\n *\n *        The terms in env must be named and their names must match their keys.\n *\n * @param {Expr|Expr[]} list\n * @param {{[s:string]: Named}} env\n * @returns {{list: Expr[], env: {[s:string]: Named}}}\n *\n * @example\n *    const expr = ski.parse(src);\n *    toposort([expr], ski.getTerms()); // returns all terms appearing in Expr in correct order\n */\nfunction toposort (list, env) {\n  if (list instanceof Expr)\n    list = [list];\n  if (env) {\n    // TODO check in[name].name === name\n    if (!list)\n      list = Object.keys(env).sort().map(k => env[k]); // ensure deterministic order\n  } else {\n    if (!list)\n      return [];\n    if (!env) {\n      env = {};\n      for (const item of list) {\n        if (!(item instanceof Named))\n          continue;\n        if (env[item.name])\n          throw new Error('duplicate name ' + item);\n        env[item.name] = item;\n      }\n    }\n  }\n\n  const out = [];\n  const seen = new Set();\n  const rec = term => {\n    if (seen.has(term))\n      return;\n    term.fold(null, (acc, e) => {\n      if (e !== term && e instanceof Named && env[e.name] === e) {\n        rec(e);\n        return Expr.control.prune(null);\n      }\n    });\n    out.push(term);\n    seen.add(term);\n  };\n\n  for (const term of list)\n    rec(term);\n\n  return {\n    list: out,\n    env,\n  };\n}\n\nExpr.native = native;\nExpr.control = control;\nExpr.extras = { toposort };\n\nmodule.exports = { Expr, App, Named, FreeVar, Lambda, Native, Alias, Church };\n", "/**\n * Combinatory logic simulator\n */\n'use strict';\n\nconst { Tokenizer, restrict } = require('./internal');\nconst classes = require('./expr');\n\nconst { Expr, Named, Native, Alias, FreeVar, Lambda, Church } = classes;\nconst { native } = Expr;\n\nclass Empty extends Expr {\n  apply (...args) {\n    return args.length ? args.shift().apply(...args) : this;\n  }\n\n  postParse () {\n    throw new Error('Attempt to use empty expression () as a term');\n  }\n}\n\nclass PartialLambda extends Empty {\n  // TODO mutable! rewrite ro when have time\n  constructor (term, known = {}) {\n    super();\n    this.impl = new Empty();\n    if (term instanceof FreeVar)\n      this.terms = [term];\n    else if (term instanceof PartialLambda) {\n      if (!(term.impl instanceof FreeVar))\n        throw new Error('Expected FreeVar->...->FreeVar->Expr');\n      this.terms = [...term.terms, term.impl];\n    } else\n      throw new Error('Expected FreeVar or PartialLambda');\n  }\n\n  apply (term, ...tail) {\n    if (term === null || tail.length !== 0 )\n      throw new Error('bad syntax in partial lambda expr');\n    this.impl = this.impl.apply(term);\n    return this;\n  }\n\n  postParse () {\n    return new Lambda(this.terms, this.impl);\n  }\n\n  // uncomment if debugging with prints\n  /* toString () {\n    return this.terms.join('->') + '->' + (this.impl ?? '???');\n  } */\n}\n\nfunction postParse (expr) {\n  return expr.postParse ? expr.postParse() : expr;\n}\n\nconst combChars = new Tokenizer(\n  '[()]', '[A-Z]', '[a-z_][a-z_0-9]*', '\\\\b[0-9]+\\\\b', '->', '\\\\+'\n);\n\nclass SKI {\n  /**\n   *\n   * @param {{\n   *    allow?: string,\n   *    numbers?: boolean,\n   *    lambdas?: boolean,\n   *    terms?: { [key: string]: Expr|string} | string[],\n   *    annotate?: boolean,\n   * }} [options]\n   */\n  constructor (options = {}) {\n    this.annotate = options.annotate ?? false;\n    this.known = { ...native };\n    this.hasNumbers = true;\n    this.hasLambdas = true;\n    /** @type {Set<string>} */\n    this.allow = new Set(Object.keys(this.known));\n\n    // Import terms, if any. Omit native ones\n    if (Array.isArray(options.terms))\n      this.bulkAdd(options.terms);\n    else if (options.terms) {\n      for (const name in options.terms) {\n        // Native terms already handled by allow\n        if (!options.terms[name].match(/^Native:/))\n          this.add(name, options.terms[name]);\n      }\n    }\n\n    // Finally, impose restrictions\n    // We must do it after recreating terms, or else terms reliant on forbidden terms will fail\n    this.hasNumbers = options.numbers ?? true;\n    this.hasLambdas = options.lambdas ?? true;\n    if (options.allow)\n      this.restrict(options.allow);\n  }\n\n  /**\n   * @desc Declare a new term\n   * If the first argument is an Alias, it is added as is.\n   * Otherwise, a new Alias or Native term (depending on impl type) is created.\n   * If note is not provided and this.annotate is true, an automatic note is generated.\n   *\n   * If impl is a function, it should have signature (Expr) => ... => Expr\n   * (see typedef Partial at top of expr.js)\n   *\n   * @example ski.add('T', 'S(K(SI))K', 'swap combinator')\n   * @example ski.add( ski.parse('T = S(K(SI))K') ) // ditto but one-arg form\n   * @example ski.add('T', x => y => y.apply(x), 'swap combinator') // heavy artillery\n   * @example ski.add('Y', function (f) { return f.apply(this.apply(f)); }, 'Y combinator')\n   *\n   * @param {Alias|String} term\n   * @param {String|Expr|function(Expr):Partial} [impl]\n   * @param {String} [note]\n   * @return {SKI} chainable\n   */\n  add (term, impl, note ) {\n    term = this._named(term, impl);\n\n    if (this.annotate && note === undefined) {\n      const guess = term.infer();\n      if (guess.expr)\n        note = guess.expr.format({ terse: true, html: true, lambda: ['', ' &mapsto; ', ''] });\n    }\n    if (note !== undefined)\n      term.note = note;\n\n    if (this.known[term.name])\n      this.known[term.name].outdated = true;\n    this.known[term.name] = term;\n    this.allow.add(term.name);\n\n    return this;\n  }\n\n  /**\n   * @desc Internal helper for add() that creates an Alias or Native term from the given arguments.\n   * @param {Alias|string} term\n   * @param {string|Expr|function(Expr):Partial} impl\n   * @returns {Native|Alias}\n   * @private\n   */\n  _named (term, impl) {\n    if (term instanceof Alias)\n      return new Alias(term.name, term.impl, { canonize: true });\n    if (typeof term !== 'string')\n      throw new Error('add(): term must be an Alias or a string');\n    if (impl === undefined)\n      throw new Error('add(): impl must be provided when term is a string');\n    if (typeof impl === 'string')\n      return new Alias(term, this.parse(impl), { canonize: true });\n    if (impl instanceof Expr)\n      return new Alias(term, impl, { canonize: true });\n    if (typeof impl === 'function')\n      return new Native(term, impl);\n    // idk what this is\n    throw new Error('add(): impl must be an Expr, a string, or a function with a signature Expr => ... => Expr');\n  }\n\n  /**\n   * @desc Declare a new term if it is not known, otherwise just allow it.\n   *       Currently only used by quests.\n   *       Use with caution, this function may change its signature, behavior, or even be removed in the future.\n   *\n   * @experimental\n   * @param {string|Alias} name\n   * @param {string|Expr|function(Expr):Partial} impl\n   * @returns {SKI}\n   */\n  maybeAdd (name, impl) {\n    if (this.known[name])\n      this.allow.add(name);\n    else\n      this.add(name, impl);\n    return this;\n  }\n\n  /**\n   * @desc Declare and remove multiple terms at once\n   *       term=impl adds term\n   *       term= removes term\n   * @param {string[]} list\n   * @return {SKI} chainable\n   */\n  bulkAdd (list) {\n    for (const item of list) {\n      const m = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\\s*=\\s*(.*)$/s);\n      // TODO check all declarations before applying any (but we might need earlier terms for parsing later ones)\n      if (!m)\n        throw new Error('bulkAdd: invalid declaration: ' + item);\n      if (m[2] === '')\n        this.remove(m[1]);\n      else\n        this.add(m[1], this.parse(m[2]));\n    }\n\n    return this;\n  }\n\n  /**\n   * Restrict the interpreter to given terms. Terms prepended with '+' will be added\n   * and terms preceeded with '-' will be removed.\n   * @example ski.restrict('SK') // use the basis\n   * @example ski.restrict('+I') // allow I now\n   * @example ski.restrict('-SKI +BCKW' ); // switch basis\n   * @example ski.restrict('-foo -bar'); // forbid some user functions\n   * @param {string} spec\n   * @return {SKI} chainable\n   */\n  restrict (spec) {\n    this.allow = restrict(this.allow, spec);\n    return this;\n  }\n\n  /**\n   *\n   * @param {string} spec\n   * @return {string}\n   */\n  showRestrict (spec = '+') {\n    const out = [];\n    let prevShort = true;\n    for (const term of [...restrict(this.allow, spec)].sort()) {\n      const nextShort = term.match(/^[A-Z]$/);\n      if (out.length && !(prevShort && nextShort))\n        out.push(' ');\n      out.push(term);\n      prevShort = nextShort;\n    }\n    return out.join('');\n  }\n\n  /**\n   *\n   * @param {String} name\n   * @return {SKI}\n   */\n  remove (name) {\n    this.known[name].outdated = true;\n    delete this.known[name];\n    this.allow.delete(name);\n    return this;\n  }\n\n  /**\n   *\n   * @return {{[key:string]: Native|Alias}}\n   */\n  getTerms () {\n    const out = {};\n    for (const name of Object.keys(this.known)) {\n      if (this.allow.has(name))\n        out[name] = this.known[name];\n    }\n    return out;\n  }\n\n  /**\n   * @desc Export term declarations for use in bulkAdd().\n   * Currently only Alias terms are serialized.\n   * @returns {string[]}\n   */\n  declare () {\n    // TODO accept argument to declare specific terms only\n    const env = this.getTerms();\n\n    // not serializing native terms, and we don't care about free vars\n    for (const name in env) {\n      if (!(env[name] instanceof Alias))\n        delete env[name];\n    }\n\n    // avert conflicts if native terms were redefined:\n    // create a temporary alias for each native term that was redefined;\n    // replace usage of redefined term in subexpressions;\n    // finally, remove the temporary aliases from the output\n    const needDetour = {};\n    let i = 1;\n    for (const name in native) {\n      if (!(env[name] instanceof Alias))\n        continue;\n      while ('tmp' + i in env)\n        i++;\n      const temp = new Alias('tmp' + i, env[name]);\n      needDetour[temp] = env[name];\n      env[temp] = temp;\n      delete env[name];\n    }\n\n    // console.log(env);\n\n    const list = Expr.extras.toposort(undefined, env).list;\n\n    const detour = new Map();\n    if (Object.keys(needDetour).length) {\n      // replace aliases with their detoured counterparts.\n      // we have to go recursive, otherwise an unrelated alias may be expanded to its impl\n      // and name infos will be erased\n      const rework = expr => {\n        return expr.traverse(e => {\n          if (!(e instanceof Alias))\n            return null; // continue\n          const newAlias = detour.get(e);\n          if (newAlias)\n            return newAlias;\n          return new Alias(e.name, rework(e.impl));\n        }) ?? expr;\n      };\n\n      for (let i = 0; i < list.length; i++) {\n        // upon processing list[i], only terms declared before it may be detoured\n        list[i] = rework(list[i], detour);\n        detour.set(needDetour[list[i].name], list[i]);\n        env[list[i].name] = list[i];\n        console.log(`list[${i}] = ${list[i].name}=${list[i].impl};`);\n      }\n      console.log('detour:', detour);\n    }\n\n    // console.log(res);\n    const out = list.map(e => needDetour[e]\n      ? e.name + '=' + needDetour[e].name + '=' + e.impl.format({ inventory: env })\n      : e.name + '=' + e.impl.format({ inventory: env })\n    );\n\n    for (const [name, temp] of detour)\n      out.push(name + '=' + temp, temp + '=');\n\n    return out;\n  }\n\n  /**\n   * @template T\n   * @param {string} source\n   * @param {Object} [options]\n   * @param {{[keys: string]: Expr}} [options.env]\n   * @param {T} [options.scope]\n   * @param {boolean} [options.numbers]\n   * @param {boolean} [options.lambdas]\n   * @param {string} [options.allow]\n   * @return {Expr}\n   */\n  parse (source, options = {}) {\n    if (typeof source !== 'string')\n      throw new Error('parse: source must be a string, got ' + typeof source);\n\n    const lines = source.replace(/\\/\\/[^\\n]*$/gm, ' ')\n      .replace(/\\/\\*.*?\\*\\//gs, ' ')\n      .trim()\n      .split(/\\s*;[\\s;]*/).filter( s => s.match(/\\S/));\n\n    const jar = { ...options.env };\n\n    let expr = new Empty();\n    for (const item of lines) {\n      if (expr instanceof Alias)\n        expr.outdated = true;\n\n      const def = item.match(/^([A-Z]|[a-z][a-z_0-9]*)\\s*=(.*)$/s);\n      if (def && def[2] === '')\n        expr = new FreeVar(def[1], options.scope ?? SKI);\n      else\n        expr = this.parseLine(item, jar, options);\n\n      if (def) {\n        if (jar[def[1]] !== undefined)\n          throw new Error('Attempt to redefine a known term: ' + def[1]);\n        jar[def[1]] = expr;\n      }\n\n      // console.log('parsed line:', item, '; got:', expr,'; jar now: ', jar);\n    }\n\n    expr.context = {\n      env:    { ...this.getTerms(), ...jar }, // also contains pre-parsed terms\n      scope:  options.scope,\n      src:    source,\n      parser: this,\n    };\n    return expr;\n  }\n\n  /**\n   * @desc Parse a single line of source code, without splitting it into declarations.\n   *       Internal, always use parse() instead.\n   * @template T\n   * @param {String} source S(KI)I\n   * @param {{[keys: string]: Expr}} env\n   * @param {Object} [options]\n   * @param {{[keys: string]: Expr}} [options.env] - unused, see 'env' argument\n   * @param {T} [options.scope]\n   * @param {boolean} [options.numbers]\n   * @param {boolean} [options.lambdas]\n   * @param {string} [options.allow]\n   * @return {Expr} parsed expression\n   */\n  parseLine (source, env = {}, options = {}) {\n    const aliased = source.match(/^\\s*([A-Z]|[a-z][a-z_0-9]*)\\s*=\\s*(.*)$/s);\n    if (aliased)\n      return new Alias(aliased[1], this.parseLine(aliased[2], env, options));\n\n    const opt = {\n      numbers: options.numbers ?? this.hasNumbers,\n      lambdas: options.lambdas ?? this.hasLambdas,\n      allow:   restrict(this.allow, options.allow),\n    };\n    // make sure '+' usage is in sync with numerals\n    opt.numbers ? opt.allow.add('+') : opt.allow.delete('+');\n\n    const tokens = combChars.split(source);\n\n    const empty = new Empty();\n    /** @type {Expr[]} */\n    const stack = [empty];\n    const context = options.scope || SKI; // default is global unbound vars\n\n    // TODO each token should carry along its position in source\n    for (const c of tokens) {\n      // console.log(\"parseLine: found \"+c+\"; stack =\", stack.join(\", \"));\n      if (c === '(')\n        stack.push(empty);\n      else if (c === ')') {\n        if (stack.length < 2)\n          throw new Error('unbalanced input: extra closing parenthesis' + source);\n        const x = postParse(stack.pop());\n        const f = stack.pop();\n        stack.push(f.apply(x));\n      } else if (c === '->') {\n        if (!opt.lambdas)\n          throw new Error('Lambdas not supported, allow them explicitly');\n        stack.push(new PartialLambda(stack.pop(), env));\n      } else if (c.match(/^[0-9]+$/)) {\n        if (!opt.numbers)\n          throw new Error('Church numbers not supported, allow them explicitly');\n        const f = stack.pop();\n        stack.push(f.apply(new Church(c)));\n      } else {\n        const f = stack.pop();\n        if (!env[c] && this.known[c] && !opt.allow.has(c)) {\n          throw new Error('Term \\'' + c + '\\' is not in the restricted set '\n            + [...opt.allow].sort().join(' '));\n        }\n        // look in temp vars first, then in known terms, then fallback to creating free var\n        const x = env[c] ?? this.known[c] ?? (env[c] = new FreeVar(c, context));\n        stack.push(f.apply(x));\n      }\n    }\n\n    if (stack.length !== 1) {\n      throw new Error('unbalanced input: missing '\n          + (stack.length - 1) + ' closing parenthesis:' + source);\n    }\n\n    return postParse(stack.pop());\n  }\n\n  toJSON () {\n    return {\n      version:  '1.1.1', // set to incremented package.json version whenever SKI serialization changes\n      allow:    this.showRestrict('+'),\n      numbers:  this.hasNumbers,\n      lambdas:  this.hasLambdas,\n      annotate: this.annotate,\n      terms:    this.declare(),\n    }\n  }\n}\n\n/**\n *  Public static shortcuts to common functions (see also ./extras.js)\n */\n\n/**\n * @desc Create a proxy object that generates variables on demand,\n *       with names corresponding to the property accessed.\n *       Different invocations will return distinct variables,\n *       even if with the same name.\n *\n *\n * @example const {x, y, z} = SKI.vars();\n *          x.name; // 'x'\n *          x instanceof FreeVar; // true\n *          x.apply(y).apply(z); // x(y)(z)\n *\n * @template T\n * @param {T} [scope] - optional context to bind the generated variables to\n * @return {{[key: string]: FreeVar}}\n */\nSKI.vars = function (scope = {}) {\n  const cache = {};\n  return new Proxy({}, {\n    get: (target, name) => {\n      if (!(name in cache))\n        cache[name] = new FreeVar(name, scope);\n      return cache[name];\n    }\n  });\n};\n\n/**\n * Convert a number to Church encoding\n * @param {number} n\n * @return {Church}\n */\nSKI.church = n => new Church(n);\n\n/**\n *\n * @type {{[key: string]: Native}}\n */\n\nfor (const name in native)\n  SKI[name] = native[name];\n\nSKI.classes = classes;\nSKI.native = native;\n/**\n * @desc Traverse control functions, used by Expr.traverse() and Expr.fold()\n * @template T\n * @type {{\n *    descend: function(T): TraverseControl<T>,\n *    prune: function(T): TraverseControl<T>,\n *    redo: function(T): TraverseControl<T>,\n *    stop: function(T): TraverseControl<T>\n * }}\n */\nSKI.control = Expr.control;\n\nmodule.exports = { SKI };\n", "const { SKI } = require('./parser');\nconst { Expr, FreeVar, Alias, Lambda } = SKI.classes;\n\n/**\n * @typedef {{\n *   pass: boolean,\n *   reason?: string,\n *   steps: number,\n *   start: Expr,\n *   found: Expr,\n *   expected: Expr,\n *   note?: string,\n *   args: Expr[],\n *   case: Case\n * }} CaseResult\n */\n\n/**\n * @typedef {{\n *   linear?: boolean,\n *   affine?: boolean,\n *   normal?: boolean,\n *   proper?: boolean,\n *   discard?: boolean,\n *   duplicate?: boolean,\n *   arity?: number,\n * }} Capability\n */\n\n/**\n * @typedef {\n *   [string, string]\n *   | [{max?: number}, string, string]\n *   | [{caps: Capability, max?: number}, string]\n * } TestCase\n */\n\n/**\n * @typedef {string | {name: string, fancy?: string, allow?: string, numbers?: boolean, lambdas?: boolean}} InputSpec\n */\n\n/**\n * @typedef {{\n *   pass: boolean,\n *   details: CaseResult[],\n *   expr?: Expr,\n *   input: Expr[]|string[],\n *   exception?: Error,\n *   steps: number,\n *   weight?: number\n * }} QuestResult\n */\n\n/**\n * @typedef {{\n *    input: InputSpec | InputSpec[],\n *    cases: TestCase[],\n *\n *    // the rest is optional\n *\n *    allow?: string,\n *    numbers?: boolean,\n *    env?: string[],\n *    engine?: SKI,\n *    engineFull?: SKI,\n *\n *    // metadata, also any fields not listed here will go to quest.meta.???\n *    id?: string|number,\n *    name?: string,\n *    intro?: string|string[], // multiple strings will be concatenated with spaces\n * }} QuestSpec\n */\n\nclass Quest {\n  /**\n   * @description A combinator problem with a set of test cases for the proposed solution.\n   * @param {QuestSpec} options\n   * @example const quest = new Quest({\n   *    input: 'identity',\n   *    cases: [\n   *      ['identity x', 'x'],\n   *    ],\n   *    allow: 'SK',\n   *    intro: 'Find a combinator that behaves like the identity function.',\n   * });\n   * quest.check('S K K'); // { pass: true, details: [...], ... }\n   * quest.check('K S');   // { pass: false, details: [...], ... }\n   * quest.check('K x');   // fail! internal variable x is not equal to free variable x,\n   *                       //     despite having the same name.\n   * quest.check('I');     // fail! I not in the allowed list.\n   */\n  constructor (options) {\n    const { input, cases, allow, numbers, lambdas, engine, engineFull, ...meta } = options;\n    const env = options.env ?? options.vars; // backwards compatibility\n\n    //\n    this.engine = engine ?? new SKI();\n    this.engineFull = engineFull ?? new SKI();\n    this.restrict = { allow, numbers: numbers ?? false, lambdas: lambdas ?? false };\n    this.env = {};\n\n    const jar = {};\n\n    // option.env is a list of expressions.\n    // we suck all free variables + all term declarations from there into this.env\n    // to feed it later to every case's parser.\n    for (const term of env ?? []) {\n      const expr = this.engineFull.parse(term, { env: jar, scope: this });\n      if (expr instanceof SKI.classes.Alias)\n        this.env[expr.name] = new Alias(expr.name, expr.impl, { terminal: true, canonize: false });\n        // Canonized aliases won't expand with insufficient arguments,\n        // causing correct solutions to fail, so alas...\n      else if (expr instanceof SKI.classes.FreeVar)\n        this.env[expr.name] = expr;\n      else\n        throw new Error('Unsupported given variable type: ' + term);\n    }\n\n    this.input = [];\n    for (const term of Array.isArray(input) ? input : [input])\n      this.addInput(term);\n    if (!this.input.length)\n      throw new Error('Quest needs at least one input placeholder');\n\n    this.envFull = { ...this.env, ...jar };\n    for (const term of this.input) {\n      if (term.name in this.envFull)\n        throw new Error('input placeholder name is duplicated or clashes with env: ' + term.name);\n      this.envFull[term.name] = term.placeholder;\n    }\n\n    // NOTE meta is a local variable, can mutate\n    // NOTE title/descr are old name/intro respectively, kept for backwards compatibility\n    this.cases = [];\n    this.name = meta.name ?? meta.title;\n    meta.intro = list2str(meta.intro ?? meta.descr);\n    this.intro = meta.intro;\n    this.id = meta.id;\n    this.meta = meta;\n\n    for (const c of cases ?? [])\n      this.add(...c);\n  }\n\n  /**\n   *   Display allowed terms based on what engine thinks of this.env + this.restrict.allow\n   *   @return {string}\n   */\n  allowed () {\n    const allow = this.restrict.allow ?? '';\n    const env  = Object.keys(this.env).sort();\n    // In case vars are present and restrictions aren't, don't clutter the output with all the known terms\n    return allow\n      ? this.engine.showRestrict(allow + '+' + env.join(' '))\n      : env.map( s => '+' + s).join(' ');\n  }\n\n  addInput (term) {\n    if (typeof term !== 'object')\n      term = { name: term };\n    if (typeof term.name !== 'string')\n      throw new Error(\"quest 'input' field must be a string or a {name: string, ...} object\");\n\n    term.placeholder = new SKI.classes.FreeVar(term.name);\n    // TODO more checks\n    this.input.push(term);\n  }\n\n  /**\n   *\n   * @param {{} | string} opt\n   * @param {string} terms\n   * @return {Quest}\n   */\n  add (opt, ...terms) {\n    if (typeof opt === 'string') {\n      terms.unshift(opt);\n      opt = {};\n    } else\n      opt = { ...opt };\n\n    opt.engine = opt.engine  ?? this.engineFull;\n    opt.env = opt.env ?? this.envFull;\n\n    const input = this.input.map( t => t.placeholder );\n    this.cases.push(\n      opt.caps\n        ? new PropertyCase(input, opt, terms)\n        : new ExprCase(input, opt, terms)\n    );\n    return this;\n  }\n\n  /**\n   * @description Statefully parse a list of strings into expressions or fancy aliases thereof.\n   * @param {string[]} input\n   * @return {{terms: Expr[], weight: number}}\n   */\n  prepare (...input) {\n    if (input.length !== this.input.length)\n      throw new Error('Solutions provided ' + input.length + ' terms where ' + this.input.length + ' are expected');\n\n    let weight = 0;\n    const prepared = [];\n    const jar = { ...this.env };\n    for (let i = 0; i < input.length; i++) {\n      const spec = this.input[i];\n      const impl = this.engine.parse(input[i], {\n        env:     jar,\n        allow:   spec.allow ?? this.restrict.allow,\n        numbers: spec.numbers ?? this.restrict.numbers,\n        lambdas: spec.lambdas ?? this.restrict.lambdas,\n      });\n      const arsenal = { ...this.engine.getTerms(), ...jar };\n      weight += impl.fold(0, (a, e) => {\n        if (e instanceof SKI.classes.Named && arsenal[e.name] === e)\n          return SKI.control.prune( a + 1);\n      });\n      const expr = impl instanceof FreeVar\n        ? impl\n        : new Alias(spec.fancy ?? spec.name, impl, { terminal: true, canonize: false });\n      jar[spec.name] = expr;\n      prepared.push(expr);\n    }\n    return {\n      prepared,\n      weight,\n    };\n  }\n\n  /**\n   *\n   * @param {string} input\n   * @return {QuestResult}\n   */\n  check (...input) {\n    try {\n      const { prepared, weight } = this.prepare(...input);\n      const details = this.cases.map( c => c.check(...prepared) );\n      const pass = details.reduce((acc, val) => acc && val.pass, true);\n      const steps = details.reduce((acc, val) => acc + val.steps, 0);\n      return {\n        expr:  prepared[0],\n        input: prepared,\n        pass,\n        steps,\n        details,\n        weight,\n      };\n    } catch (e) {\n      return { pass: false, details: [], exception: e, steps: 0, input };\n    }\n  }\n\n  /**\n     *\n     * @return {TestCase[]}\n     */\n  show () {\n    return [...this.cases];\n  }\n}\n\nclass Case {\n  /**\n   * @param {FreeVar[]} input\n   * @param {{\n   *   max?: number,\n   *   note?: string,\n   *   env?: {[key:string]: Expr},\n   *   engine: SKI\n   * }} options\n   */\n  constructor (input, options) {\n    this.max = options.max ?? 1000;\n    this.note = options.note;\n    this.env = { ...(options.env ?? {}) }; // note: env already contains input placeholders\n    this.input = input;\n    this.engine = options.engine;\n  }\n\n  parse (src) {\n    return new Subst(this.engine.parse(src, { env: this.env, scope: this }), this.input);\n  }\n\n  /**\n   * @param {Expr} expr\n   * @return {CaseResult}\n   */\n  check ( ...expr ) {\n    throw new Error('not implemented');\n  }\n}\n\nclass ExprCase extends Case {\n  /**\n   * @param {FreeVar[]} input\n   * @param {{\n   *    max?: number,\n   *    note?: string,\n   *    env?: {string: Expr},\n   *    engine?: SKI\n   * }} options\n   * @param {[e1: string, e2: string]} terms\n   */\n  constructor (input, options, terms) {\n    if (terms.length !== 2)\n      throw new Error('Case accepts exactly 2 strings');\n\n    super(input, options);\n\n    [this.e1, this.e2] = terms.map( s => this.parse(s) );\n  }\n\n  check (...args) {\n    const e1 = this.e1.apply(args);\n    const r1 = e1.run({ max: this.max });\n    const e2 = this.e2.apply(args);\n    const r2 = e2.run({ max: this.max });\n\n    let reason = null;\n    if (!r1.final || !r2.final)\n      reason = 'failed to reach normal form in ' + this.max + ' steps';\n    else\n      reason = r1.expr.diff(r2.expr);\n\n    return {\n      pass:     !reason,\n      reason,\n      steps:    r1.steps,\n      start:    e1,\n      found:    r1.expr,\n      expected: r2.expr,\n      note:     this.note,\n      args,\n      case:     this,\n    };\n  }\n}\n\nconst knownCaps = {\n  normal:    true,\n  proper:    true,\n  discard:   true,\n  duplicate: true,\n  linear:    true,\n  affine:    true,\n  arity:     true,\n}\n\nclass PropertyCase extends Case {\n  // test that an expression uses all of its inputs exactly once\n  constructor (input, options, terms) {\n    super(input, options);\n    if (terms.length > 1)\n      throw new Error('PropertyCase accepts exactly 1 string');\n    if (!options.caps || typeof options.caps !== 'object' || !Object.keys(options.caps).length)\n      throw new Error('PropertyCase requires a caps object with at least one capability');\n    const unknown = Object.keys(options.caps).filter( c => !knownCaps[c] );\n    if (unknown.length)\n      throw new Error('PropertyCase: don\\'t know how to test these capabilities: ' + unknown.join(', '));\n\n    this.expr = this.parse(terms[0]);\n    this.caps = options.caps;\n\n    if (this.caps.linear) {\n      delete this.caps.linear;\n      this.caps.duplicate = false;\n      this.caps.discard = false;\n      this.caps.normal = true;\n    }\n\n    if (this.caps.affine) {\n      delete this.caps.affine;\n      this.caps.normal = true;\n      this.caps.duplicate = false;\n    }\n  }\n\n  check (...expr) {\n    const start = this.expr.apply(expr);\n    const r = start.run({ max: this.max });\n    const guess = r.expr.infer({ max: this.max });\n\n    const reason = [];\n    for (const cap in this.caps) {\n      if (guess[cap] !== this.caps[cap])\n        reason.push('expected property ' + cap + ' to be ' + this.caps[cap] + ', found ' + guess[cap]);\n    }\n\n    return {\n      pass:   !reason.length,\n      reason: reason ? reason.join('\\n') : null,\n      steps:  r.steps,\n      start,\n      found:  r.expr,\n      case:   this,\n      note:   this.note,\n      args:   expr,\n    };\n  }\n}\n\nclass Subst {\n  /**\n   * @descr A placeholder object with exactly n free variables to be substituted later.\n   * @param {Expr} expr\n   * @param {FreeVar[]} env\n   */\n  constructor (expr, env) {\n    this.expr = expr;\n    this.env = env;\n  }\n\n  apply (list) {\n    if (list.length !== this.env.length)\n      throw new Error('Subst: expected ' + this.env.length + ' terms, got ' + list.length);\n\n    let expr = this.expr;\n    for (let i = 0; i < this.env.length; i++)\n      expr = expr.subst(this.env[i], list[i]) ?? expr;\n\n    return expr;\n  }\n}\n\n/**\n * @desc Concatenate long strings represented as arrays, or just pass along if already string or undefined.\n * @param {string|Array<string>|undefined} str\n * @returns {string|undefined}\n */\nfunction list2str (str) {\n  if (str === undefined || typeof str === 'string')\n    return str;\n  return Array.isArray(str) ? str.join(' ') : '' + str;\n}\n\nmodule.exports = { Quest };\n", "'use strict';\n\nconst { Expr, Alias, FreeVar } = require('./expr');\n\n/**\n * @desc  Extra utilities that do not belong in the core.\n */\n\n/**\n * @experimental\n * @desc  Look for an expression that matches the predicate,\n *        starting with the seed and applying the terms to one another.\n *\n *        A predicate returning 0 (or nothing) means \"keep looking\",\n *        a positive number stands for \"found\",\n *        and a negative means \"discard this term from further applications\".\n *\n *        The order of search is from shortest to longest expressions.\n *\n * @param {Expr[]} seed\n * @param {object} options\n * @param {number} [options.depth] - maximum generation to search for\n * @param {number} [options.tries] - maximum number of tries before giving up\n * @param {boolean} [options.infer] - whether to call infer(), default true.\n * @param {number} [options.maxArgs] - arguments in infer()\n * @param {number} [options.max] - step limit in infer()\n * @param {boolean} [options.noskip] - prevents skipping equivalent terms. Always true if infer is false.\n * @param {boolean} [retain] - if true. also add the whole cache to returned value\n * @param {({gen: number, total: number, probed: number, step: boolean}) => void} [options.progress]\n * @param {number} [options.progressInterval] - minimum number of tries between calls to options.progress, default 1000.\n * @param {(e: Expr, props: {}) => number?} predicate\n * @return {{expr?: Expr, total: number, probed: number, gen: number, cache?: Expr[][]}}\n */\nfunction search (seed, options, predicate) {\n  const {\n    depth = 16,\n    infer = true,\n    progressInterval = 1000,\n  } = options;\n  const hasSeen = infer && !options.noskip;\n\n  // cache[i] = ith generation, 0 is empty\n  const cache = [[]];\n  let total = 0;\n  let probed = 0;\n  const seen = {};\n\n  const maybeProbe = term => {\n    total++;\n    const props = infer ? term.infer({ max: options.max, maxArgs: options.maxArgs }) : null;\n    if (hasSeen && props.expr) {\n      if (seen[props.expr])\n        return { res: -1 };\n      seen[props.expr] = true;\n    }\n    probed++;\n    const res = predicate(term, props);\n    return { res, props };\n  };\n\n  // sieve through the seed\n  for (const term of seed) {\n    const { res } = maybeProbe(term);\n    if (res > 0)\n      return { expr: term, total, probed, gen: 1 };\n    else if (res < 0)\n      continue;\n\n    cache[0].push(term);\n  }\n\n  let lastProgress;\n\n  for (let gen = 1; gen < depth; gen++) {\n    if (options.progress) {\n      options.progress({ gen, total, probed, step: true });\n      lastProgress = total;\n    }\n    for (let i = 0; i < gen; i++) {\n      for (const a of cache[gen - i - 1] || []) {\n        for (const b of cache[i] || []) {\n          if (total >= options.tries)\n            return { total, probed, gen, ...(options.retain ? { cache } : {}) };\n          if (options.progress && total - lastProgress >= progressInterval) {\n            options.progress({ gen, total, probed, step: false });\n            lastProgress = total;\n          }\n          const term = a.apply(b);\n          const { res, props } = maybeProbe(term);\n\n          if (res > 0)\n            return { expr: term, total, probed, gen, ...(options.retain ? { cache } : {}) };\n          else if (res < 0)\n            continue;\n\n          // if the term is not reducible, it is more likely to be a dead end, so we push it further away\n          const offset = infer\n            ? ((props.expr ? 0 : 3) + (props.dup ? 1 : 0) + (props.proper ? 0 : 1))\n            : 0;\n          if (!cache[gen + offset])\n            cache[gen + offset] = [];\n          cache[gen + offset].push(term);\n        }\n      }\n    }\n  }\n\n  return { total, probed, gen: depth, ...(options.retain ? { cache } : {}) };\n}\n\n/**\n * @desc Recursively replace all instances of Expr in a data structure with\n *       respective string representation using the format() options.\n *       Objects of other types and primitive values are eft as is.\n *\n *       May be useful for debugging or diagnostic output.\n *\n * @experimental\n *\n * @param {any} obj\n * @param {object} [options] - see Expr.format()\n * @returns {any}\n */\nfunction deepFormat (obj, options = {}) {\n  if (obj instanceof Expr)\n    return obj.format(options);\n  if (Array.isArray(obj))\n    return obj.map(deepFormat);\n  if (typeof obj !== 'object' || obj === null || obj.constructor !== Object)\n    return obj;\n\n  // default = plain object\n  const out = {};\n  for (const key in obj)\n    out[key] = deepFormat(obj[key]);\n\n  return out;\n}\n\n/**\n * @desc  Given an expression and a hash of named terms,\n *        return a semicolon-separated string that declares said expression\n *        unambiguously.\n *\n * @example\n * var expr = ski.parse(\"T=CI; V=BCT; V x y\");\n * SKI.extras.declare(expr, expr.context.env);\n * // 'B; C; I; T=CI; V=BC(T); x=; y=; Vx y'\n *\n * @param {Expr} expr\n * @param {{[s: string]: Named}} [env]\n * @returns {string}\n */\nfunction declare (expr, env) {\n  const res = Expr.extras.toposort([expr], env);\n\n  return res.list.map(s => {\n    if (s instanceof Alias)\n      return s.name + '=' + s.impl.format({ inventory: res.env });\n    if (s instanceof FreeVar)\n      return s.name + '=';\n    return s.format({ inventory: res.env });\n  }).join('; ');\n}\n\nmodule.exports = { search, deepFormat, declare };\n", "const { SKI } = require('./src/parser');\nconst { Quest } = require('./src/quest');\nconst extras = require('./src/extras');\n\nSKI.Quest = Quest;\nSKI.extras = { ...extras, ...SKI.classes.Expr.extras };\n\n// SKI_REPL=1 node -r ./index.js\nif (typeof process === 'object' && process.env.SKI_REPL && typeof global !== 'undefined') {\n  global.SKI = SKI;\n  console.log('SKI_REPL activated, try `new SKI();`');\n}\n\n// we're in a browser\nif (typeof window !== 'undefined')\n  window.SKI = SKI;\n\nmodule.exports = { SKI, Quest }; // TODO remove Quest on next breaking release, it's in SKI already!\n"],
+  "mappings": "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",
   "names": ["exports", "module", "exports", "module", "exports", "module", "SKI", "i", "exports", "module", "SKI", "Quest", "exports", "module"]
 }