@dallaylaen/ski-interpreter 2.3.2 → 2.3.3

package/lib/ski-interpreter.min.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 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\nconst ORDER = {\n  'leftmost-outermost': 'LO',\n  'leftmost-innermost': 'LI',\n  LO:                   'LO',\n  LI:                   'LI',\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 * @desc List of predefined native combinators.\n * This is required for toSKI() to work, otherwise could as well have been in parser.js.\n * @type {{[key: string]: Native}}\n */\nconst native = {};\n\n/**\n * @typedef {Expr | function(Expr): Partial} Partial\n */\n\n/**\n * @typedef {{\n *   normal: boolean,      // whether the term becomes irreducible after receiving a number of arguments.\n *                         // if false, other properties may be missing.\n *   proper: boolean,      // whether the irreducible form is only contains its arguments. implies normal.\n *   arity?: number,       // the number of arguments that is sufficient to reach the normal form\n *                         // absent unless normal.\n *   discard?: boolean,    // whether the term (or subterms, unless proper) can discard arguments.\n *   duplicate?: boolean,  // whether the term (or subterms, unless proper) can duplicate arguments.\n *   skip?: Set<number>,   // indices of arguments that are discarded. nonempty inplies discard.\n *   dup?: Set<number>,    // indices of arguments that are duplicated. nonempty implies duplicate.\n *   expr?: Expr,          // canonical form containing lambdas, applications, and variables, if any\n *   steps?: number,       // number of steps taken to obtain the aforementioned information, if applicable\n * }} TermInfo\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   * @property {number} [arity] - number of arguments the term is waiting for (if known)\n   * @property {string} [note] - a brief description what the term does\n   * @property {string} [fancyName] - how to display in html mode, e.g. &phi; instead of 'f'\n   *                Typically only applicable to descendants of Named.\n   * @property {TermInfo} [props] - properties inferred from the term's behavior\n   */\n\n  /**\n   *\n   * @desc Define properties of the term based on user supplied options and/or inference results.\n   *       Typically useful for declaring Native and Alias terms.\n   * @private\n   * @param {Object} options\n   * @param {string} [options.note] - a brief description what the term does\n   * @param {number} [options.arity] - number of arguments the term is waiting for (if known)\n   * @param {string} [options.fancy] - how to display in html mode, e.g. &phi; instead of 'f'\n   * @param {boolean} [options.canonize] - whether to try to infer the properties\n   * @param {number} [options.max] - maximum number of steps for inference, if canonize is true\n   * @param {number} [options.maxArgs] - maximum number of arguments for inference, if canonize is true\n   * @return {this}\n   */\n  _setup (options = {}) {\n    // TODO better name\n\n    if (options.fancy !== undefined)\n      this.fancyName = options.fancyName;\n\n    if (options.note !== undefined)\n      this.note = options.note;\n\n    if (options.arity !== undefined)\n      this.arity = options.arity;\n\n    if (options.canonize) {\n      const guess = this.infer(options);\n      if (guess.normal) {\n        this.arity = this.arity ?? guess.arity;\n        this.note = this.note ?? guess.expr.format({ html: true, lambda: ['', ' &mapsto; ', ''] });\n        delete guess.steps;\n        this.props = guess;\n      }\n    }\n    return this;\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   *       A null/undefined value is interpreted as\n   *       \"descend further if applicable, or leave the node unchanged\".\n   *\n   *       Returned values may be decorated:\n   *\n   *       SKI.control.prune will suppress further descending even if nothing was returned\n   *       SKI.control.stop will terminate further changes.\n   *       SKI.control.redo will apply the callback to the returned subtree, recursively.\n   *\n   *       Note that if redo was applied at least once to a subtree, a null return from the same subtree\n   *       will be replaced by the last non-null value returned.\n   *\n   *       The traversal order is leftmost-outermost, unless options.order = 'leftmost-innermost' is specified.\n   *       Short aliases 'LO' and 'LI' (case-sensitive) are also accepted.\n   *\n   *       Returns null if no changes were made, or the new expression otherwise.\n   *\n   * @param {{\n   *   order?: 'LO' | 'LI' | 'leftmost-outermost' | 'leftmost-innermost',\n   * }} [options]\n   * @param {(e:Expr) => TraverseValue<Expr>} change\n   * @returns {Expr|null}\n   */\n  traverse (options, change) {\n    if (typeof options === 'function') {\n      change = options;\n      options = {};\n    }\n    const order = ORDER[options.order ?? 'LO'];\n    if (order === undefined)\n      throw new Error('Unknown traversal order: ' + options.order);\n    const [expr, _] = unwrap(this._traverse_redo({ order }, change));\n    return expr;\n  }\n\n  /**\n   * @private\n   * @param {Object} options\n   * @param {(e:Expr) => TraverseValue<Expr>} change\n   * @returns {TraverseValue<Expr>}\n   */\n  _traverse_redo (options, change) {\n    let action;\n    let expr = this;\n    let prev;\n    do {\n      prev = expr;\n      const next = options.order === 'LI'\n        ? expr._traverse_descend(options, change) ?? change(expr)\n        : change(expr) ?? expr._traverse_descend(options, change);\n      [expr, action] = unwrap(next);\n    } while (expr && action === control.redo);\n    if (!expr && prev !== this)\n      expr = prev; // we were in redo at least once\n    return action ? action(expr) : expr;\n  }\n\n  /**\n   * @private\n   * @param {Object} options\n   * @param {(e:Expr) => TraverseValue<Expr>} change\n   * @returns {TraverseValue<Expr>}\n   */\n\n  _traverse_descend (options, change) {\n    return null;\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    // TODO remove in next breaking release\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 {TermInfo}\n   */\n  infer (options = {}) {\n    return this._infer({\n      max:     options.max ?? DEFAULTS.max,\n      maxArgs: options.maxArgs ?? DEFAULTS.maxArgs,\n    }, 0);\n  }\n\n  /**\n   * @desc Internal method for infer(), which performs the actual inference.\n   * @param {{max: number, maxArgs: number}} options\n   * @param {number} nargs - var index to avoid name clashes\n   * @returns {TermInfo}\n   * @private\n   */\n  _infer (options, nargs) {\n    const probe = [];\n    let steps = 0;\n    let expr = this;\n    // eslint-disable-next-line no-labels\n    main: for (let i = 0; i < options.maxArgs; i++) {\n      const next = expr.run({ max: options.max - steps });\n      // console.log(`infer step ${i}, expr = ${expr}, probe = [${probe}]: `, next);\n      steps += next.steps;\n      if (!next.final)\n        break;\n      if (firstVar(next.expr)) {\n        // can't append more variables, return or recurse\n        expr = next.expr;\n        if (!expr.any(e => !(e instanceof FreeVar || e instanceof App)))\n          return maybeLambda(probe, expr, { steps });\n        const list = expr.unroll();\n        let discard = false;\n        let duplicate = false;\n        const acc = [];\n        for (let j = 1; j < list.length; j++) {\n          const sub = list[j]._infer(\n            { maxArgs: options.maxArgs - nargs, max: options.max - steps }, // limit recursion\n            nargs + i // avoid variable name clashes\n          );\n          steps += sub.steps;\n          if (!sub.expr)\n            // eslint-disable-next-line no-labels\n            break main; // press f to pay respects\n          if (sub.discard)\n            discard = true;\n          if (sub.duplicate)\n            duplicate = true;\n          acc.push(sub.expr);\n        }\n        return maybeLambda(probe, list[0].apply(...acc), { discard, duplicate, steps });\n      }\n      const push = nthvar(nargs + i);\n      probe.push(push);\n      expr = next.expr.apply(push);\n    }\n    return { normal: false, proper: false, 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    let 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    const seen = new Set(); // prine irreducible\n    let steps = 0;\n    while (expr) {\n      const next = expr.traverse({ order: 'LI' }, e => {\n        if (seen.has(e))\n          return null;\n        if (e instanceof App && e.fun instanceof Lambda) {\n          const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });\n          steps += guess.steps;\n          if (!guess.normal) {\n            seen.add(e);\n            return null;\n          }\n          return control.stop(guess.expr);\n        }\n      });\n      yield { expr, steps };\n      expr = next;\n    }\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    // get rid of non-lambdas\n    let expr = this.traverse(e => {\n      if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)\n        return null;\n      // TODO infer failed for atomic term? die...\n      return e.infer().expr;\n    }) ?? this;\n\n    let steps = 0;\n    while (expr) {\n      const next = expr.traverse({ order: 'LI' }, e => {\n        if (!(e instanceof Lambda) || (e.impl instanceof Lambda))\n          return null; // continue\n        if (e.impl === e.arg)\n          return control.stop(native.I);\n        if (!e.impl.any(t => t === e.arg))\n          return control.stop(native.K.apply(e.impl));\n        // TODO use real assert here. e.impl contains e.arg and also isn't e.arg, in MUST be App.\n        if (!(e.impl instanceof App))\n          throw new Error('toSKI: assert failed: lambda body is of unexpected type ' + e.impl.constructor.name );\n        // eta-reduction: body === (not e.arg) (e.arg)\n        if (e.impl.arg === e.arg && !e.impl.fun.any(t => t === e.arg))\n          return control.stop(e.impl.fun);\n        // last resort, go S\n        return control.stop(native.S.apply(new Lambda(e.arg, e.impl.fun), new Lambda(e.arg, e.impl.arg)));\n      })\n      yield { expr, steps, final: !next };\n      steps++;\n      expr = next;\n    }\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   *\n   * `this` is the expected value and the argument is the actual one.\n   * Mnemonic: the expected value is always a combinator, the actual one may be anything.\n   *\n   * @param {Expr} actual\n   * @param {string} comment\n   */\n  expect (actual, comment = '') {\n    comment = comment ? comment + ': ' : '';\n    if (!(actual instanceof Expr)) {\n      throw new Error(comment + 'Expected a combinator but found '\n        + (actual?.constructor?.name ?? typeof actual));\n    }\n    const diff = this.diff(actual);\n    if (!diff)\n      return; // all good\n\n    // TODO wanna use AssertionError but browser doesn't recognize it\n    // still the below hack works for mocha-based tests.\n    const poorMans = new Error(comment + diff);\n    poorMans.expected = this.diag();\n    poorMans.actual = actual.diag();\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      // no indent increase so that a diff between diags is consistent with how `equals` works.\n      if (e instanceof Alias)\n        return [`${indent}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  }\n  /** @property {boolean} [final] */\n\n  weight () {\n    return this.fun.weight() + this.arg.weight();\n  }\n\n  _traverse_descend (options, change) {\n    const [fun, fAction] = unwrap(this.fun._traverse_redo(options, change));\n    if (fAction === control.stop)\n      return control.stop(fun ? fun.apply(this.arg) : null);\n\n    const [arg, aAction] = unwrap(this.arg._traverse_redo(options, change));\n\n    const final = (fun || arg) ? (fun ?? this.fun).apply(arg ?? this.arg) : null;\n    if (aAction === control.stop)\n      return control.stop(final);\n    return final;\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  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   * By convention, FreeVar.global is a constant denoting a global unbound variable.\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\nFreeVar.global = ['global'];\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 }} [opt]\n   */\n  constructor (name, impl, opt = {}) {\n    super(name);\n    // setup essentials\n    this.invoke  = impl;\n\n    this._setup({ canonize: true, ...opt });\n  }\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  invoke (arg) {\n    return this.impl.subst(this.arg, arg) ?? this.impl;\n  }\n\n  _traverse_descend (options, change) {\n    // alas no proper shielding of self.arg is possible\n    const [impl, iAction] = unwrap(this.impl._traverse_redo(options, change));\n\n    const final = impl ? new Lambda(this.arg, impl) : null;\n\n    return iAction === control.stop ? control.stop(final) : final;\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  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 Expr {\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    n = Number.parseInt(n);\n    if (!(n >= 0))\n      throw new Error('Church number must be a non-negative integer');\n    super();\n    this.invoke = x => y => {\n      let expr = y;\n      for (let i = n; i-- > 0; )\n        expr = x.apply(expr);\n      return expr;\n    };\n\n    /** @type {number} */\n    this.n = n;\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  _format (options, nargs) {\n    return nargs >= 2\n      ? options.redex[0] + this.n + options.redex[1]\n      : this.n + '';\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    this._setup(options);\n    this.terminal = options.terminal ?? this.props?.proper;\n    this.invoke = waitn(impl, this.arity ?? 0);\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_descend (options, change) {\n    return this.impl._traverse_redo(options, 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  // 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  _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\n\nfunction addNative (name, impl, opt) {\n  native[name] = new Native(name, impl, opt);\n}\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 firstVar (expr) {\n  // yay premature optimization\n  while (expr instanceof App)\n    expr = expr.fun;\n  return expr instanceof FreeVar;\n}\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 {TermInfo}\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    normal:    true,\n    steps:     caps.steps,\n    expr:      args.length ? new Lambda(args, expr) : expr,\n    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 * @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 {object|string} [options]\n   * @param {string} [options.note] - optional annotation for the term, default is auto-generated if this.annotate is true\n   * @param {boolean} [options.canonize] - whether to canonize the term's implementation, default is this.annotate\n   * @param {boolean} [options.fancy] - alternative HTML-friendly name for the term\n   * @param {number} [options.arity] - custom arity for the term, default is inferred from the implementation\n   * @return {SKI} chainable\n   */\n  add (term, impl, options ) {\n    term = this._named(term, impl);\n\n    // backward compat\n    if (typeof options === 'string')\n      options = { note: options, canonize: false };\n    term._setup({ canonize: this.annotate, ...options });\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 ?? FreeVar.global);\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 || FreeVar.global; // 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\n/**\n * @typedef {{ accepted?: string[][], rejected?: string[][] }} SelfCheck\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  verify (options) {\n    const findings = this.verifyMeta(options);\n    if (options.solutions) {\n      const solCheck = this.verifySolutions(options.solutions);\n      if (solCheck)\n        findings.solutions = solCheck;\n    }\n    if (options.seen) {\n      if (!this.id)\n        findings.seen = 'No id in quest ' + (this.name ?? '(unnamed)');\n      if (options.seen.has(this.id))\n        findings.seen = 'Duplicate quest id ' + this.id;\n      options.seen.add(this.id); // mutating but who cares\n    }\n    return Object.keys(findings).length ? findings : null;\n  }\n\n  /**\n   * @desc Verify that solutions that are expected to pass/fail do so.\n   * @param {SelfCheck|{[key: string]: SelfCheck}} dataset\n   * @return {{shouldPass: {input: string[], result: QuestResult}[], shouldFail: {input: string[], result: QuestResult}[]} | null}\n   */\n  verifySolutions (dataset) {\n    // dataset is either a SelfCheck object or a hash of { quest_id: SelfCheck }\n    if (typeof dataset === 'object' && !Array.isArray(dataset?.accepted) && !Array.isArray(dataset?.rejected)) {\n      // dataset is a hash of { quest_id: SelfCheck } so extract data\n      if (!this.id || !dataset[this.id])\n        return null; // no self-check data for this quest, skip\n    }\n\n    const { accepted = [], rejected = [] } = dataset[this.id] ?? dataset;\n\n    const ret = { shouldPass: [], shouldFail: [] };\n    for (const input of accepted) {\n      const result = this.check(...input);\n      if (!result.pass)\n        ret.shouldPass.push({ input, result });\n    }\n    for (const input of rejected) {\n      const result = this.check(...input);\n      if (result.pass)\n        ret.shouldFail.push({ input, result });\n    }\n    return (ret.shouldFail.length + ret.shouldPass.length) ? ret : null; // return null if all good\n  }\n\n  verifyMeta (options = {}) {\n    const findings = {};\n\n    for (const field of ['name', 'intro']) {\n      const found = checkHtml(this[field]);\n      if (found)\n        findings[field] = found;\n    }\n    if (options.date) {\n      const date = new Date(this.meta.created_at);\n      if (isNaN(date))\n        findings.date = 'invalid date format: ' + this.meta.created_at;\n      else if (date < new Date('2024-07-15') || date > new Date())\n        findings.date = 'date out of range: ' + this.meta.created_at;\n    }\n\n    return findings;\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// corresponds to \"chapter\" in the quest page\nclass Group {\n  constructor (options) {\n    this.name = options.name;\n    this.intro = list2str(options.intro);\n    this.id = options.id;\n\n    // TODO don't die on failed quests\n    if (options.content)\n      this.content = options.content.map( c => c instanceof Quest ? c : new Quest(c) );\n  }\n\n  verify (options) {\n    const findings = {};\n    const id = checkId(this.id, options.seen);\n    if (id)\n      findings[this.id] = id;\n    for (const field of ['name', 'intro']) {\n      const found = checkHtml(this[field]);\n      if (found)\n        findings[field] = found;\n    }\n\n    findings.content = this.content.map(q => q.verify(options));\n    return findings;\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\nfunction checkId (id, seen) {\n  if (id === undefined)\n    return 'missing';\n  if (typeof id !== 'string' && typeof id !== 'number' )\n    return 'is a ' + typeof id;\n  if (seen) {\n    if (seen.has(id))\n      return 'duplicate id ' + id;\n    seen.add(id);\n  }\n  // return nothing = success\n}\n\nfunction checkHtml (str) {\n  if (str === undefined)\n    return 'missing';\n  if (typeof str !== 'string')\n    return 'not a string but ' + typeof str;\n\n  // very basic check for unclosed tags, just to catch common mistakes in the quest text\n  const tagStack = [];\n  const tagRegex = /<\\/?([a-z]+)(?:\\s[^>]*)?>/gi;\n  let match;\n  while ((match = tagRegex.exec(str)) !== null) {\n    const [fullTag, tagName] = match;\n    if (fullTag.startsWith('</')) {\n      // Closing tag\n      if (tagStack.length === 0 || tagStack.pop() !== tagName)\n        return (`Unmatched closing tag: </${tagName}>`);\n    } else {\n      // Opening tag\n      tagStack.push(tagName);\n    }\n  }\n  if (tagStack.length > 0)\n    return (`Unclosed tags: ${tagStack.join(', ')}`);\n\n  return null; // No issues found\n}\n\nQuest.Group = Group;\nQuest.Case = Case;\n\nmodule.exports = { Quest };\n", "'use strict';\n\nconst { Expr, Alias, FreeVar } = require('./expr');\nconst { Quest } = require('./quest');\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  // TODO for quests, use toJSON when it's ready\n  if (obj instanceof Quest)\n    return 'Quest(' + obj.name + ')';\n  if (obj instanceof Quest.Case)\n    return 'Quest.Case';\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\n/**\n * @experimental\n * @desc  Fold an application tree bottom to top.\n *        For each subtree, the function is given the term in the root position and\n *        a list of the results of folding its arguments.\n *\n *        E,g, fold('x y (z t)', f) results in f(x, [f(y, []), f(z, [f(t, [])])])\n *\n * @template T\n * @param {Expr} expr\n * @param {(head: Expr, tail: T[]) => T} fun\n * @return {T}\n */\n\nfunction foldr (expr, fun) {\n  const [head, ...tail] = expr.unroll();\n  return fun(head, tail.map(e => foldr(e, fun)));\n}\n\nmodule.exports = { search, deepFormat, declare, foldr };\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": ["require_internal", "__commonJSMin", "exports", "module", "Tokenizer", "terms", "src", "s", "a", "b", "str", "list", "last", "x", "tokRestrict", "restrict", "set", "spec", "out", "act", "sym", "mode", "TraverseControl", "value", "decoration", "unwrap", "prepareWrapper", "label", "fun", "require_expr", "__commonJSMin", "exports", "module", "unwrap", "prepareWrapper", "DEFAULTS", "ORDER", "control", "native", "Expr", "_Expr", "options", "guess", "args", "expr", "arg", "App", "Alias", "FreeVar", "change", "order", "_", "action", "prev", "next", "predicate", "initial", "combine", "value", "nargs", "probe", "steps", "main", "i", "firstVar", "e", "maybeLambda", "list", "discard", "duplicate", "acc", "j", "sub", "push", "nthvar", "Lambda", "seen", "t", "search", "replace", "opt", "max", "final", "other", "swap", "actual", "comment", "diff", "poorMans", "first", "fallback", "rec", "indent", "_App", "fun", "fAction", "aAction", "fValue", "aValue", "partial", "wrap", "Named", "_Named", "name", "freeId", "_FreeVar", "scope", "lhs", "rhs", "Native", "impl", "_Lambda", "my", "tail", "known", "last", "local", "iAction", "iValue", "Church", "_Church", "n", "x", "y", "waitn", "addNative", "z", "f", "caps", "count", "proper", "index", "a", "skip", "dup", "toposort", "env", "k", "item", "out", "term", "require_parser", "__commonJSMin", "exports", "module", "Tokenizer", "restrict", "classes", "Expr", "Named", "Native", "Alias", "FreeVar", "Lambda", "Church", "native", "Empty", "args", "PartialLambda", "_PartialLambda", "term", "known", "tail", "postParse", "expr", "combChars", "SKI", "options", "name", "impl", "list", "item", "m", "spec", "out", "prevShort", "nextShort", "env", "needDetour", "i", "temp", "detour", "rework", "e", "newAlias", "source", "lines", "s", "jar", "def", "aliased", "opt", "tokens", "empty", "stack", "context", "c", "x", "f", "scope", "cache", "target", "n", "require_quest", "__commonJSMin", "exports", "module", "SKI", "Expr", "FreeVar", "Alias", "Lambda", "Quest", "options", "input", "cases", "allow", "numbers", "lambdas", "engine", "engineFull", "meta", "env", "jar", "term", "expr", "list2str", "c", "s", "opt", "terms", "t", "PropertyCase", "ExprCase", "weight", "prepared", "i", "spec", "impl", "arsenal", "a", "e", "details", "pass", "acc", "val", "steps", "findings", "solCheck", "dataset", "accepted", "rejected", "ret", "result", "field", "found", "checkHtml", "date", "Case", "src", "Subst", "args", "e1", "r1", "r2", "reason", "knownCaps", "unknown", "start", "guess", "cap", "list", "Group", "id", "checkId", "q", "str", "seen", "tagStack", "tagRegex", "match", "fullTag", "tagName", "require_extras", "__commonJSMin", "exports", "module", "Expr", "Alias", "FreeVar", "Quest", "search", "seed", "options", "predicate", "depth", "infer", "progressInterval", "hasSeen", "cache", "total", "probed", "seen", "maybeProbe", "term", "props", "res", "lastProgress", "gen", "i", "a", "b", "offset", "deepFormat", "obj", "out", "key", "declare", "expr", "env", "s", "foldr", "fun", "head", "tail", "e", "require_index", "__commonJSMin", "exports", "module", "SKI", "Quest", "extras"]
+  "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\nconst ORDER = {\n  'leftmost-outermost': 'LO',\n  'leftmost-innermost': 'LI',\n  LO:                   'LO',\n  LI:                   'LI',\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 * @desc List of predefined native combinators.\n * This is required for toSKI() to work, otherwise could as well have been in parser.js.\n * @type {{[key: string]: Native}}\n */\nconst native = {};\n\n/**\n * @typedef {Expr | function(Expr): Partial} Partial\n */\n\n/**\n * @typedef {{\n *   normal: boolean,      // whether the term becomes irreducible after receiving a number of arguments.\n *                         // if false, other properties may be missing.\n *   proper: boolean,      // whether the irreducible form is only contains its arguments. implies normal.\n *   arity?: number,       // the number of arguments that is sufficient to reach the normal form\n *                         // absent unless normal.\n *   discard?: boolean,    // whether the term (or subterms, unless proper) can discard arguments.\n *   duplicate?: boolean,  // whether the term (or subterms, unless proper) can duplicate arguments.\n *   skip?: Set<number>,   // indices of arguments that are discarded. nonempty inplies discard.\n *   dup?: Set<number>,    // indices of arguments that are duplicated. nonempty implies duplicate.\n *   expr?: Expr,          // canonical form containing lambdas, applications, and variables, if any\n *   steps?: number,       // number of steps taken to obtain the aforementioned information, if applicable\n * }} TermInfo\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   * @property {number} [arity] - number of arguments the term is waiting for (if known)\n   * @property {string} [note] - a brief description what the term does\n   * @property {string} [fancyName] - how to display in html mode, e.g. &phi; instead of 'f'\n   *                Typically only applicable to descendants of Named.\n   * @property {TermInfo} [props] - properties inferred from the term's behavior\n   */\n\n  /**\n   *\n   * @desc Define properties of the term based on user supplied options and/or inference results.\n   *       Typically useful for declaring Native and Alias terms.\n   * @private\n   * @param {Object} options\n   * @param {string} [options.note] - a brief description what the term does\n   * @param {number} [options.arity] - number of arguments the term is waiting for (if known)\n   * @param {string} [options.fancy] - how to display in html mode, e.g. &phi; instead of 'f'\n   * @param {boolean} [options.canonize] - whether to try to infer the properties\n   * @param {number} [options.max] - maximum number of steps for inference, if canonize is true\n   * @param {number} [options.maxArgs] - maximum number of arguments for inference, if canonize is true\n   * @return {this}\n   */\n  _setup (options = {}) {\n    // TODO better name\n\n    if (options.fancy !== undefined)\n      this.fancyName = options.fancyName;\n\n    if (options.note !== undefined)\n      this.note = options.note;\n\n    if (options.arity !== undefined)\n      this.arity = options.arity;\n\n    if (options.canonize) {\n      const guess = this.infer(options);\n      if (guess.normal) {\n        this.arity = this.arity ?? guess.arity;\n        this.note = this.note ?? guess.expr.format({ html: true, lambda: ['', ' &mapsto; ', ''] });\n        delete guess.steps;\n        this.props = guess;\n      }\n    }\n    return this;\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   *       A null/undefined value is interpreted as\n   *       \"descend further if applicable, or leave the node unchanged\".\n   *\n   *       Returned values may be decorated:\n   *\n   *       SKI.control.prune will suppress further descending even if nothing was returned\n   *       SKI.control.stop will terminate further changes.\n   *       SKI.control.redo will apply the callback to the returned subtree, recursively.\n   *\n   *       Note that if redo was applied at least once to a subtree, a null return from the same subtree\n   *       will be replaced by the last non-null value returned.\n   *\n   *       The traversal order is leftmost-outermost, unless options.order = 'leftmost-innermost' is specified.\n   *       Short aliases 'LO' and 'LI' (case-sensitive) are also accepted.\n   *\n   *       Returns null if no changes were made, or the new expression otherwise.\n   *\n   * @param {{\n   *   order?: 'LO' | 'LI' | 'leftmost-outermost' | 'leftmost-innermost',\n   * }} [options]\n   * @param {(e:Expr) => TraverseValue<Expr>} change\n   * @returns {Expr|null}\n   */\n  traverse (options, change) {\n    if (typeof options === 'function') {\n      change = options;\n      options = {};\n    }\n    const order = ORDER[options.order ?? 'LO'];\n    if (order === undefined)\n      throw new Error('Unknown traversal order: ' + options.order);\n    const [expr, _] = unwrap(this._traverse_redo({ order }, change));\n    return expr;\n  }\n\n  /**\n   * @private\n   * @param {Object} options\n   * @param {(e:Expr) => TraverseValue<Expr>} change\n   * @returns {TraverseValue<Expr>}\n   */\n  _traverse_redo (options, change) {\n    let action;\n    let expr = this;\n    let prev;\n    do {\n      prev = expr;\n      const next = options.order === 'LI'\n        ? expr._traverse_descend(options, change) ?? change(expr)\n        : change(expr) ?? expr._traverse_descend(options, change);\n      [expr, action] = unwrap(next);\n    } while (expr && action === control.redo);\n    if (!expr && prev !== this)\n      expr = prev; // we were in redo at least once\n    return action ? action(expr) : expr;\n  }\n\n  /**\n   * @private\n   * @param {Object} options\n   * @param {(e:Expr) => TraverseValue<Expr>} change\n   * @returns {TraverseValue<Expr>}\n   */\n\n  _traverse_descend (options, change) {\n    return null;\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   * @experimental\n   * @desc  Fold an application tree bottom to top.\n   *        For each subtree, the function is given the term in the root position and\n   *        a list of the results of folding its arguments.\n   *\n   *        E.g. fold('x y (z t)', f) results in f(x, [f(y, []), f(z, [f(t, [])])])\n   *\n   * @example expr.foldBottomUp((head, tail) => {\n   *    if (head.arity && head.arity <= tail.length) {\n   *      return '(<span class=\"redex\">'\n   *          + head + ' '\n   *          + tail.slice(0, head.arity).join(' ')\n   *          + '</span>'\n   *          + tail.slice(head.arity).join(' ')\n   *          + ')';\n   *    } else {\n   *       return '(' + head + ' ' + tail.join(' ') + ')';\n   *    }\n   * });\n   * @template T\n   * @param {(head: Expr, tail: T[]) => T} fun\n   * @return {T}\n   */\n  foldBottomUp (fun) {\n    const [head, ...tail] = this.unroll();\n    return fun(head, tail.map(e => e.foldBottomUp(fun)));\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    // TODO remove in next breaking release\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 {TermInfo}\n   */\n  infer (options = {}) {\n    return this._infer({\n      max:     options.max ?? DEFAULTS.max,\n      maxArgs: options.maxArgs ?? DEFAULTS.maxArgs,\n    }, 0);\n  }\n\n  /**\n   * @desc Internal method for infer(), which performs the actual inference.\n   * @param {{max: number, maxArgs: number}} options\n   * @param {number} nargs - var index to avoid name clashes\n   * @returns {TermInfo}\n   * @private\n   */\n  _infer (options, nargs) {\n    const probe = [];\n    let steps = 0;\n    let expr = this;\n    // eslint-disable-next-line no-labels\n    main: for (let i = 0; i < options.maxArgs; i++) {\n      const next = expr.run({ max: options.max - steps });\n      // console.log(`infer step ${i}, expr = ${expr}, probe = [${probe}]: `, next);\n      steps += next.steps;\n      if (!next.final)\n        break;\n      if (firstVar(next.expr)) {\n        // can't append more variables, return or recurse\n        expr = next.expr;\n        if (!expr.any(e => !(e instanceof FreeVar || e instanceof App)))\n          return maybeLambda(probe, expr, { steps });\n        const list = expr.unroll();\n        let discard = false;\n        let duplicate = false;\n        const acc = [];\n        for (let j = 1; j < list.length; j++) {\n          const sub = list[j]._infer(\n            { maxArgs: options.maxArgs - nargs, max: options.max - steps }, // limit recursion\n            nargs + i // avoid variable name clashes\n          );\n          steps += sub.steps;\n          if (!sub.expr)\n            // eslint-disable-next-line no-labels\n            break main; // press f to pay respects\n          if (sub.discard)\n            discard = true;\n          if (sub.duplicate)\n            duplicate = true;\n          acc.push(sub.expr);\n        }\n        return maybeLambda(probe, list[0].apply(...acc), { discard, duplicate, steps });\n      }\n      const push = nthvar(nargs + i);\n      probe.push(push);\n      expr = next.expr.apply(push);\n    }\n    return { normal: false, proper: false, 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    let 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    const seen = new Set(); // prine irreducible\n    let steps = 0;\n    while (expr) {\n      const next = expr.traverse({ order: 'LI' }, e => {\n        if (seen.has(e))\n          return null;\n        if (e instanceof App && e.fun instanceof Lambda) {\n          const guess = e.infer({ max: options.max, maxArgs: options.maxArgs });\n          steps += guess.steps;\n          if (!guess.normal) {\n            seen.add(e);\n            return null;\n          }\n          return control.stop(guess.expr);\n        }\n      });\n      yield { expr, steps };\n      expr = next;\n    }\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    // get rid of non-lambdas\n    let expr = this.traverse(e => {\n      if (e instanceof FreeVar || e instanceof App || e instanceof Lambda || e instanceof Alias)\n        return null;\n      // TODO infer failed for atomic term? die...\n      return e.infer().expr;\n    }) ?? this;\n\n    let steps = 0;\n    while (expr) {\n      const next = expr.traverse({ order: 'LI' }, e => {\n        if (!(e instanceof Lambda) || (e.impl instanceof Lambda))\n          return null; // continue\n        if (e.impl === e.arg)\n          return control.stop(native.I);\n        if (!e.impl.any(t => t === e.arg))\n          return control.stop(native.K.apply(e.impl));\n        // TODO use real assert here. e.impl contains e.arg and also isn't e.arg, in MUST be App.\n        if (!(e.impl instanceof App))\n          throw new Error('toSKI: assert failed: lambda body is of unexpected type ' + e.impl.constructor.name );\n        // eta-reduction: body === (not e.arg) (e.arg)\n        if (e.impl.arg === e.arg && !e.impl.fun.any(t => t === e.arg))\n          return control.stop(e.impl.fun);\n        // last resort, go S\n        return control.stop(native.S.apply(new Lambda(e.arg, e.impl.fun), new Lambda(e.arg, e.impl.arg)));\n      })\n      yield { expr, steps, final: !next };\n      steps++;\n      expr = next;\n    }\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   *\n   * `this` is the expected value and the argument is the actual one.\n   * Mnemonic: the expected value is always a combinator, the actual one may be anything.\n   *\n   * @param {Expr} actual\n   * @param {string} comment\n   */\n  expect (actual, comment = '') {\n    comment = comment ? comment + ': ' : '';\n    if (!(actual instanceof Expr)) {\n      throw new Error(comment + 'Expected a combinator but found '\n        + (actual?.constructor?.name ?? typeof actual));\n    }\n    const diff = this.diff(actual);\n    if (!diff)\n      return; // all good\n\n    // TODO wanna use AssertionError but browser doesn't recognize it\n    // still the below hack works for mocha-based tests.\n    const poorMans = new Error(comment + diff);\n    poorMans.expected = this.diag();\n    poorMans.actual = actual.diag();\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      // no indent increase so that a diff between diags is consistent with how `equals` works.\n      if (e instanceof Alias)\n        return [`${indent}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  }\n  /** @property {boolean} [final] */\n\n  weight () {\n    return this.fun.weight() + this.arg.weight();\n  }\n\n  _traverse_descend (options, change) {\n    const [fun, fAction] = unwrap(this.fun._traverse_redo(options, change));\n    if (fAction === control.stop)\n      return control.stop(fun ? fun.apply(this.arg) : null);\n\n    const [arg, aAction] = unwrap(this.arg._traverse_redo(options, change));\n\n    const final = (fun || arg) ? (fun ?? this.fun).apply(arg ?? this.arg) : null;\n    if (aAction === control.stop)\n      return control.stop(final);\n    return final;\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  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   * By convention, FreeVar.global is a constant denoting a global unbound variable.\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\nFreeVar.global = ['global'];\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 }} [opt]\n   */\n  constructor (name, impl, opt = {}) {\n    super(name);\n    // setup essentials\n    this.invoke  = impl;\n\n    this._setup({ canonize: true, ...opt });\n  }\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  invoke (arg) {\n    return this.impl.subst(this.arg, arg) ?? this.impl;\n  }\n\n  _traverse_descend (options, change) {\n    // alas no proper shielding of self.arg is possible\n    const [impl, iAction] = unwrap(this.impl._traverse_redo(options, change));\n\n    const final = impl ? new Lambda(this.arg, impl) : null;\n\n    return iAction === control.stop ? control.stop(final) : final;\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  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 Expr {\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    n = Number.parseInt(n);\n    if (!(n >= 0))\n      throw new Error('Church number must be a non-negative integer');\n    super();\n    this.invoke = x => y => {\n      let expr = y;\n      for (let i = n; i-- > 0; )\n        expr = x.apply(expr);\n      return expr;\n    };\n\n    /** @type {number} */\n    this.n = n;\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  _format (options, nargs) {\n    return nargs >= 2\n      ? options.redex[0] + this.n + options.redex[1]\n      : this.n + '';\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    this._setup(options);\n    this.terminal = options.terminal ?? this.props?.proper;\n    this.invoke = waitn(impl, this.arity ?? 0);\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_descend (options, change) {\n    return this.impl._traverse_redo(options, 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  // 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  _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\n\nfunction addNative (name, impl, opt) {\n  native[name] = new Native(name, impl, opt);\n}\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 firstVar (expr) {\n  // yay premature optimization\n  while (expr instanceof App)\n    expr = expr.fun;\n  return expr instanceof FreeVar;\n}\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 {TermInfo}\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    normal:    true,\n    steps:     caps.steps,\n    expr:      args.length ? new Lambda(args, expr) : expr,\n    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 * @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 {object|string} [options]\n   * @param {string} [options.note] - optional annotation for the term, default is auto-generated if this.annotate is true\n   * @param {boolean} [options.canonize] - whether to canonize the term's implementation, default is this.annotate\n   * @param {boolean} [options.fancy] - alternative HTML-friendly name for the term\n   * @param {number} [options.arity] - custom arity for the term, default is inferred from the implementation\n   * @return {SKI} chainable\n   */\n  add (term, impl, options ) {\n    term = this._named(term, impl);\n\n    // backward compat\n    if (typeof options === 'string')\n      options = { note: options, canonize: false };\n    term._setup({ canonize: this.annotate, ...options });\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 ?? FreeVar.global);\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 || FreeVar.global; // 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\n/**\n * @typedef {{ accepted?: string[][], rejected?: string[][] }} SelfCheck\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  verify (options) {\n    const findings = this.verifyMeta(options);\n    if (options.solutions) {\n      const solCheck = this.verifySolutions(options.solutions);\n      if (solCheck)\n        findings.solutions = solCheck;\n    }\n    if (options.seen) {\n      if (!this.id)\n        findings.seen = 'No id in quest ' + (this.name ?? '(unnamed)');\n      if (options.seen.has(this.id))\n        findings.seen = 'Duplicate quest id ' + this.id;\n      options.seen.add(this.id); // mutating but who cares\n    }\n    return Object.keys(findings).length ? findings : null;\n  }\n\n  /**\n   * @desc Verify that solutions that are expected to pass/fail do so.\n   * @param {SelfCheck|{[key: string]: SelfCheck}} dataset\n   * @return {{shouldPass: {input: string[], result: QuestResult}[], shouldFail: {input: string[], result: QuestResult}[]} | null}\n   */\n  verifySolutions (dataset) {\n    // dataset is either a SelfCheck object or a hash of { quest_id: SelfCheck }\n    if (typeof dataset === 'object' && !Array.isArray(dataset?.accepted) && !Array.isArray(dataset?.rejected)) {\n      // dataset is a hash of { quest_id: SelfCheck } so extract data\n      if (!this.id || !dataset[this.id])\n        return null; // no self-check data for this quest, skip\n    }\n\n    const { accepted = [], rejected = [] } = dataset[this.id] ?? dataset;\n\n    const ret = { shouldPass: [], shouldFail: [] };\n    for (const input of accepted) {\n      const result = this.check(...input);\n      if (!result.pass)\n        ret.shouldPass.push({ input, result });\n    }\n    for (const input of rejected) {\n      const result = this.check(...input);\n      if (result.pass)\n        ret.shouldFail.push({ input, result });\n    }\n    return (ret.shouldFail.length + ret.shouldPass.length) ? ret : null; // return null if all good\n  }\n\n  verifyMeta (options = {}) {\n    const findings = {};\n\n    for (const field of ['name', 'intro']) {\n      const found = checkHtml(this[field]);\n      if (found)\n        findings[field] = found;\n    }\n    if (options.date) {\n      const date = new Date(this.meta.created_at);\n      if (isNaN(date))\n        findings.date = 'invalid date format: ' + this.meta.created_at;\n      else if (date < new Date('2024-07-15') || date > new Date())\n        findings.date = 'date out of range: ' + this.meta.created_at;\n    }\n\n    return findings;\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// corresponds to \"chapter\" in the quest page\nclass Group {\n  constructor (options) {\n    this.name = options.name;\n    this.intro = list2str(options.intro);\n    this.id = options.id;\n\n    // TODO don't die on failed quests\n    if (options.content)\n      this.content = options.content.map( c => c instanceof Quest ? c : new Quest(c) );\n  }\n\n  verify (options) {\n    const findings = {};\n    const id = checkId(this.id, options.seen);\n    if (id)\n      findings[this.id] = id;\n    for (const field of ['name', 'intro']) {\n      const found = checkHtml(this[field]);\n      if (found)\n        findings[field] = found;\n    }\n\n    findings.content = this.content.map(q => q.verify(options));\n    return findings;\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\nfunction checkId (id, seen) {\n  if (id === undefined)\n    return 'missing';\n  if (typeof id !== 'string' && typeof id !== 'number' )\n    return 'is a ' + typeof id;\n  if (seen) {\n    if (seen.has(id))\n      return 'duplicate id ' + id;\n    seen.add(id);\n  }\n  // return nothing = success\n}\n\nfunction checkHtml (str) {\n  if (str === undefined)\n    return 'missing';\n  if (typeof str !== 'string')\n    return 'not a string but ' + typeof str;\n\n  // very basic check for unclosed tags, just to catch common mistakes in the quest text\n  const tagStack = [];\n  const tagRegex = /<\\/?([a-z]+)(?:\\s[^>]*)?>/gi;\n  let match;\n  while ((match = tagRegex.exec(str)) !== null) {\n    const [fullTag, tagName] = match;\n    if (fullTag.startsWith('</')) {\n      // Closing tag\n      if (tagStack.length === 0 || tagStack.pop() !== tagName)\n        return (`Unmatched closing tag: </${tagName}>`);\n    } else {\n      // Opening tag\n      tagStack.push(tagName);\n    }\n  }\n  if (tagStack.length > 0)\n    return (`Unclosed tags: ${tagStack.join(', ')}`);\n\n  return null; // No issues found\n}\n\nQuest.Group = Group;\nQuest.Case = Case;\n\nmodule.exports = { Quest };\n", "'use strict';\n\nconst { Expr, Alias, FreeVar } = require('./expr');\nconst { Quest } = require('./quest');\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  // TODO for quests, use toJSON when it's ready\n  if (obj instanceof Quest)\n    return 'Quest(' + obj.name + ')';\n  if (obj instanceof Quest.Case)\n    return 'Quest.Case';\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": ["require_internal", "__commonJSMin", "exports", "module", "Tokenizer", "terms", "src", "s", "a", "b", "str", "list", "last", "x", "tokRestrict", "restrict", "set", "spec", "out", "act", "sym", "mode", "TraverseControl", "value", "decoration", "unwrap", "prepareWrapper", "label", "fun", "require_expr", "__commonJSMin", "exports", "module", "unwrap", "prepareWrapper", "DEFAULTS", "ORDER", "control", "native", "Expr", "_Expr", "options", "guess", "args", "expr", "arg", "App", "Alias", "FreeVar", "change", "order", "_", "action", "prev", "next", "predicate", "initial", "combine", "value", "fun", "head", "tail", "e", "nargs", "probe", "steps", "main", "i", "firstVar", "maybeLambda", "list", "discard", "duplicate", "acc", "j", "sub", "push", "nthvar", "Lambda", "seen", "t", "search", "replace", "opt", "max", "final", "other", "swap", "actual", "comment", "diff", "poorMans", "first", "fallback", "rec", "indent", "_App", "fAction", "aAction", "fValue", "aValue", "partial", "wrap", "Named", "_Named", "name", "freeId", "_FreeVar", "scope", "lhs", "rhs", "Native", "impl", "_Lambda", "my", "known", "last", "local", "iAction", "iValue", "Church", "_Church", "n", "x", "y", "waitn", "addNative", "z", "f", "caps", "count", "proper", "index", "a", "skip", "dup", "toposort", "env", "k", "item", "out", "term", "require_parser", "__commonJSMin", "exports", "module", "Tokenizer", "restrict", "classes", "Expr", "Named", "Native", "Alias", "FreeVar", "Lambda", "Church", "native", "Empty", "args", "PartialLambda", "_PartialLambda", "term", "known", "tail", "postParse", "expr", "combChars", "SKI", "options", "name", "impl", "list", "item", "m", "spec", "out", "prevShort", "nextShort", "env", "needDetour", "i", "temp", "detour", "rework", "e", "newAlias", "source", "lines", "s", "jar", "def", "aliased", "opt", "tokens", "empty", "stack", "context", "c", "x", "f", "scope", "cache", "target", "n", "require_quest", "__commonJSMin", "exports", "module", "SKI", "Expr", "FreeVar", "Alias", "Lambda", "Quest", "options", "input", "cases", "allow", "numbers", "lambdas", "engine", "engineFull", "meta", "env", "jar", "term", "expr", "list2str", "c", "s", "opt", "terms", "t", "PropertyCase", "ExprCase", "weight", "prepared", "i", "spec", "impl", "arsenal", "a", "e", "details", "pass", "acc", "val", "steps", "findings", "solCheck", "dataset", "accepted", "rejected", "ret", "result", "field", "found", "checkHtml", "date", "Case", "src", "Subst", "args", "e1", "r1", "r2", "reason", "knownCaps", "unknown", "start", "guess", "cap", "list", "Group", "id", "checkId", "q", "str", "seen", "tagStack", "tagRegex", "match", "fullTag", "tagName", "require_extras", "__commonJSMin", "exports", "module", "Expr", "Alias", "FreeVar", "Quest", "search", "seed", "options", "predicate", "depth", "infer", "progressInterval", "hasSeen", "cache", "total", "probed", "seen", "maybeProbe", "term", "props", "res", "lastProgress", "gen", "i", "a", "b", "offset", "deepFormat", "obj", "out", "key", "declare", "expr", "env", "s", "require_index", "__commonJSMin", "exports", "module", "SKI", "Quest", "extras"]
 }