kni 4.0.3 → 5.0.0

package/engine.js

@@ -1,246 +1,299 @@
-'use strict';
+import evaluate from './evaluate.js';
+import describe from './describe.js';
 
-var Story = require('./story');
-var evaluate = require('./evaluate');
-var describe = require('./describe');
+const weigh = (scope, randomer, expressions, weights) => {
+  let weight = 0;
+  for (let i = 0; i < expressions.length; i++) {
+    weights[i] = evaluate(scope, randomer, expressions[i]);
+    weight += weights[i];
+  }
+  return weight;
+};
 
-module.exports = Engine;
+const pick = (weights, weight, randomer) => {
+  const offset = Math.floor(randomer.random() * weight);
+  let passed = 0;
+  for (let i = 0; i < weights.length; i++) {
+    passed += weights[i];
+    if (offset < passed) {
+      return i;
+    }
+  }
+  return null;
+};
+
+const pop = (array, index) => {
+  array[index] = array[array.length - 1];
+  array.length--;
+};
 
-var debug = typeof process === 'object' && process.env.DEBUG_ENGINE;
+export default class Engine {
+  debug = typeof process === 'object' && process.env.DEBUG_ENGINE;
 
-function Engine(args) {
-    // istanbul ignore next
-    var self = this;
+  constructor(args) {
     this.story = args.story;
     this.labels = Object.keys(this.story);
     this.handler = args.handler;
+    this.meter = 0;
+    this.limit = 10e3; // bottles.kni, for example, runs long
     this.options = [];
     this.keywords = {};
     this.noOption = null;
     this.global = new Global(this.handler);
     this.top = this.global;
-    // istanbul ignore next
     this.start = args.start || 'start';
     this.label = this.start;
-    this.instruction = new Story.constructors.goto(this.start);
+    this.instruction = {type: 'goto', next: this.start};
     this.render = args.render;
     this.dialog = args.dialog;
     this.dialog.engine = this;
-    // istanbul ignore next
     this.randomer = args.randomer || Math;
-    this.debug = debug;
     this.waypoint = this.capture();
+    this.answerOnClearMeterFault = [];
     Object.seal(this);
-}
+  }
 
-Engine.prototype.reset = function reset() {
-    Engine.call(this, this);
+  reset() {
+    this.labels = Object.keys(this.story);
+    this.options = [];
+    this.keywords = {};
+    this.noOption = null;
+    this.global = new Global(this.handler);
+    this.top = this.global;
+    this.label = this.start;
+    this.instruction = {type: 'goto', next: this.start};
+    this.waypoint = this.capture();
     this.resume();
-};
+  }
+
+  /**
+   * Runs the event loop until it yields.
+   */
+  continue() {
+    this.meter = 0;
+    for (;;) {
+      if (this.debug) {
+        console.log(`${this.label} ${this.instruction.type} ${describe(this.instruction)}`);
+        console.log(this.top);
+      }
+      if (this.instruction == null) {
+        // TODO user error for non-console interaction.
+        console.log(`The label ${JSON.stringify(this.label)} does not exist in this story`);
+        this.end();
+        return;
+      }
+      if (!this[`$${this.instruction.type}`]) {
+        console.error(`Unexpected instruction type: ${this.instruction.type}`, this.instruction);
+        this.resume();
+      }
+      const proceed = this[`$${this.instruction.type}`](this.instruction);
+      if (!proceed) {
+        return;
+      }
+      this.meter += 1;
+      if (this.meter >= this.limit) {
+        this.display();
+        this.dialog.meterFault();
+        return;
+      }
+    }
+  }
 
-Engine.prototype.continue = function _continue() {
-    var _continue;
-    do {
-        // istanbul ignore if
-        if (this.debug) {
-            console.log(this.label + ' ' +  this.instruction.type + ' ' + describe(this.instruction));
-        }
-        // istanbul ignore if
-        if (this.instruction == null) {
-            // TODO user error for non-console interaction.
-            console.log('The label ' + JSON.stringify(this.label) + ' does not exist in this story');
-            this.end();
-            return;
-        }
-        // istanbul ignore if
-        if (!this['$' + this.instruction.type]) {
-            console.error('Unexpected instruction type: ' + this.instruction.type, this.instruction);
-            this.resume();
-        }
-        _continue = this['$' + this.instruction.type](this.instruction);
-    } while (_continue);
-};
+  clearMeterFault() {
+    if (this.meter >= this.limit) {
+      this.render.clear();
+      this.continue();
 
-Engine.prototype.goto = function _goto(label) {
+      // flush answers posted while faulted
+      const count = this.answerOnClearMeterFault.length;
+      const answers = this.answerOnClearMeterFault.splice(0, count);
+      for (const answer of answers) {
+        this.answer(answer);
+      }
+    }
+  }
+
+  goto(label) {
     while (this.top != null && (label == 'ESC' || label === 'RET')) {
-        // istanbul ignore if
-        if (this.debug) {
-            console.log(label.toLowerCase());
-        }
-        if (this.top.stopOption) {
-            this.render.stopOption();
-        }
-        if (label === 'ESC') {
-            label = this.top.branch;
-        } else {
-            label = this.top.next;
-        }
-        this.top = this.top.parent;
+      if (this.debug) {
+        console.log(label.toLowerCase());
+      }
+      if (this.top.stopOption) {
+        this.render.stopOption();
+      }
+      if (label === 'ESC') {
+        label = this.top.branch;
+      } else {
+        label = this.top.next;
+      }
+      this.top = this.top.parent;
     }
 
     if (label === 'RET') {
-        return this.end();
+      return this.end();
     }
 
-    var next = this.story[label];
-    // istanbul ignore if
+    const next = this.story[label];
     if (!next) {
-        console.error('Story missing label', label);
-        return this.resume();
+      console.error('Story missing label', label);
+      return this.resume();
     }
-    // istanbul ignore if
     if (!next) {
-        console.error('Story missing instruction for label: ' + label);
-        return this.resume();
+      console.error(`Story missing instruction for label: ${label}`);
+      return this.resume();
     }
     if (this.handler && this.handler.goto) {
-        this.handler.goto(label, next);
+      this.handler.goto(label, next);
     }
     this.label = label;
     this.instruction = next;
     return true;
-};
+  }
 
-Engine.prototype.gothrough = function gothrough(sequence, next) {
-    var prev = this.label;
-    for (var i = sequence.length - 1; i >= 0; i--) {
-        if (next !== 'RET') {
-            this.top = new Frame(this.top, [], next, 'RET', prev);
-        }
-        prev = next;
-        next = sequence[i];
+  gothrough(sequence, next) {
+    let prev = this.label;
+    for (let i = sequence.length - 1; i >= 0; i--) {
+      if (next !== 'RET') {
+        this.top = new Frame(this.top, [], next, 'RET', prev);
+      }
+      prev = next;
+      next = sequence[i];
     }
     return this.goto(next);
-};
+  }
 
-Engine.prototype.end = function end() {
+  end() {
+    this.display();
     if (this.handler && this.handler.end) {
-        this.handler.end(this);
+      this.handler.end(this);
     }
-    this.display();
     this.dialog.close();
     return false;
-};
+  }
 
-Engine.prototype.ask = function ask() {
+  ask() {
     if (this.options.length) {
-        this.display();
-        if (this.handler && this.handler.ask) {
-            this.handler.ask(this);
-        }
-        this.dialog.ask();
+      this.display();
+      if (this.handler && this.handler.ask) {
+        this.handler.ask(this);
+      }
+      this.dialog.ask();
     } else if (this.noOption != null) {
-        var closure = this.noOption;
-        var option = this.story[closure.label];
-        this.top = closure.scope;
-        var answer = option.answer;
-        this.flush();
-        this.gothrough(answer, 'RET');
-        this.continue();
+      const closure = this.noOption;
+      const option = this.story[closure.label];
+      this.top = closure.scope;
+      const answer = option.answer;
+      this.flush();
+      this.gothrough(answer, 'RET');
+      this.continue();
     } else {
-        return this.goto('RET');
+      return this.goto('RET');
     }
-};
+  }
 
-Engine.prototype.read = function read() {
+  read() {
     this.display();
     if (this.handler && this.handler.ask) {
-        this.handler.ask(this);
+      this.handler.ask(this);
     }
     this.dialog.ask(this.instruction.cue);
-};
+  }
 
-Engine.prototype.answer = function answer(text) {
+  answer(text) {
+    if (this.meter >= this.limit) {
+      this.answerOnClearMeterFault.push(text);
+      return;
+    }
     if (this.handler && this.handler.answer) {
-        this.handler.answer(text, this);
+      this.handler.answer(text, this);
     }
     this.render.flush();
     if (this.instruction.type === 'read') {
-        this.top.set(this.instruction.variable, text);
-        this.render.clear();
-        if (this.goto(this.instruction.next)) {
-            this.continue();
-        }
-        return;
+      this.top.set(this.instruction.variable, text);
+      this.render.clear();
+      if (this.goto(this.instruction.next)) {
+        this.continue();
+      }
+      return;
     }
-    var choice = text - 1;
+    const choice = text - 1;
     if (choice >= 0 && choice < this.options.length) {
-        return this.choice(this.options[choice]);
+      return this.choice(this.options[choice]);
     } else if (this.keywords[text]) {
-        return this.choice(this.keywords[text]);
+      return this.choice(this.keywords[text]);
     } else {
-        this.render.pardon();
-        this.ask();
+      this.render.pardon();
+      this.ask();
     }
-};
+  }
 
-Engine.prototype.choice = function _choice(closure) {
-    var option = this.story[closure.label];
+  choice(closure) {
+    const option = this.story[closure.label];
     if (this.handler && this.handler.choice) {
-        this.handler.choice(option, this);
+      this.handler.choice(option, this);
     }
     this.render.clear();
     this.waypoint = this.capture(closure);
     if (this.handler && this.handler.waypoint) {
-        this.handler.waypoint(this.waypoint, this);
+      this.handler.waypoint(this.waypoint, this);
     }
     // Resume in the option's closure scope.
     this.top = closure.scope;
     // There is no known case where gothrough would immediately exit for
     // lack of further instructions, so
-    // istanbul ignore else
     if (this.gothrough(option.answer, 'RET')) {
-        this.flush();
-        this.continue();
+      this.flush();
+      this.continue();
     }
-};
+  }
 
-Engine.prototype.display = function display() {
+  display() {
     this.render.display();
-};
+  }
 
-Engine.prototype.flush = function flush() {
+  flush() {
     this.options.length = 0;
     this.noOption = null;
     this.keywords = {};
-};
+  }
 
-Engine.prototype.write = function write(text) {
+  write(text) {
     this.render.write(this.instruction.lift, text, this.instruction.drop);
     return this.goto(this.instruction.next);
-};
+  }
 
-// istanbul ignore next
-Engine.prototype.capture = function capture(closure) {
-    var label, top;
+  capture(closure) {
+    let label, top;
     if (closure != null) {
-        label = closure.label;
-        top = closure.scope;
+      label = closure.label;
+      top = closure.scope;
     } else {
-        label = this.label;
-        top = this.top;
+      label = this.label;
+      top = this.top;
     }
 
-    var stack = [];
+    const stack = [];
     for (; top != this.global; top = top.parent) {
-        stack.push(top.capture(this));
+      stack.push(top.capture(this));
     }
 
     return [
-        this.indexOfLabel(label),
-        stack,
-        this.global.capture(),
-        [
-            this.randomer._state0U | 0,
-            this.randomer._state0L | 0,
-            this.randomer._state1U | 0,
-            this.randomer._state1L | 0
-        ],
+      this.indexOfLabel(label),
+      stack,
+      this.global.capture(),
+      [
+        this.randomer._state0U | 0,
+        this.randomer._state0L | 0,
+        this.randomer._state1U | 0,
+        this.randomer._state1L | 0,
+      ],
     ];
-};
+  }
 
-// istanbul ignore next
-Engine.prototype.resume = function resume(snapshot) {
+  /**
+   * Resumes from a snapshot.
+   */
+  resume(snapshot) {
     this.render.clear();
     this.flush();
     this.label = this.start;
@@ -248,30 +301,30 @@ Engine.prototype.resume = function resume(snapshot) {
     this.global = new Global(this.handler);
     this.top = this.global;
     if (snapshot == null) {
-        if (this.handler && this.handler.waypoint) {
-            this.handler.waypoint(null, this);
-        }
-        this.continue();
-        return;
+      if (this.handler && this.handler.waypoint) {
+        this.handler.waypoint(null, this);
+      }
+      this.continue();
+      return;
     }
 
     // Destructure snapshot
-    var label = this.labelOfIndex(snapshot[0]);
-    var stack = snapshot[1];
-    var global = snapshot[2];
-    var random = snapshot[3];
+    const label = this.labelOfIndex(snapshot[0]);
+    const stack = snapshot[1];
+    const global = snapshot[2];
+    const random = snapshot[3];
 
     // Restore globals
-    var keys = global[0];
-    var values = global[1];
-    for (var i = 0; i < keys.length; i++) {
-        this.global.set(keys[i], values[i]);
+    const keys = global[0];
+    const values = global[1];
+    for (let i = 0; i < keys.length; i++) {
+      this.global.set(keys[i], values[i]);
     }
 
     // Restore stack
-    var engine = this;
+    const engine = this;
     this.top = stack.reduceRight(function (parent, snapshot) {
-        return Frame.restore(engine, snapshot, parent);
+      return Frame.restore(engine, snapshot, parent);
     }, this.global);
 
     // Restore prng
@@ -280,72 +333,86 @@ Engine.prototype.resume = function resume(snapshot) {
     this.randomer._state1U = random[2];
     this.randomer._state1L = random[3];
 
-    var instruction = this.story[label];
+    const instruction = this.story[label];
     if (instruction.type === 'opt') {
-        if (this.gothrough(instruction.answer, 'RET')) {
-            this.flush();
-            this.continue();
-        }
-    } else {
-        this.label = label;
+      if (this.gothrough(instruction.answer, 'RET')) {
         this.flush();
         this.continue();
+      }
+    } else {
+      this.label = label;
+      this.flush();
+      this.continue();
     }
-};
+  }
 
-// istanbul ignore next
-Engine.prototype.log = function log() {
+  log() {
     this.top.log();
     console.log('');
-};
+  }
 
-// Here begin the instructions
+  labelOfIndex(index) {
+    if (index == -2) {
+      return 'RET';
+    } else if (index === -3) {
+      return 'ESC';
+    }
+    return this.labels[index];
+  }
 
-Engine.prototype.$text = function $text() {
+  indexOfLabel(label) {
+    if (label === 'RET') {
+      return -2;
+    } else if (label === 'ESC') {
+      return -3;
+    }
+    return this.labels.indexOf(label);
+  }
+
+  // Here begin the instructions
+
+  $text() {
     return this.write(this.instruction.text);
-};
+  }
 
-Engine.prototype.$echo = function $echo() {
-    return this.write('' + evaluate(this.top, this.randomer, this.instruction.expression));
-};
+  $echo() {
+    return this.write(`${evaluate(this.top, this.randomer, this.instruction.expression)}`);
+  }
 
-Engine.prototype.$br = function $br() {
+  $br() {
     this.render.break();
     return this.goto(this.instruction.next);
-};
+  }
 
-Engine.prototype.$par = function $par() {
+  $par() {
     this.render.paragraph();
     return this.goto(this.instruction.next);
-};
+  }
 
-Engine.prototype.$rule = function $rule() {
+  $rule() {
     // TODO
     this.render.paragraph();
     return this.goto(this.instruction.next);
-};
+  }
 
-Engine.prototype.$goto = function $goto() {
+  $goto() {
     return this.goto(this.instruction.next);
-};
+  }
 
-Engine.prototype.$call = function $call() {
-    var label = this.instruction.label;
-    var def = this.story[label];
-    // istanbul ignore if
+  $call() {
+    const label = this.instruction.label;
+    const def = this.story[label];
     if (!def) {
-        console.error('no such procedure ' + label, this.instruction);
-        return this.resume();
+      console.error(`no such procedure ${label}`, this.instruction);
+      return this.resume();
     }
-    // istanbul ignore if
     if (def.type !== 'def') {
-        console.error('Can\'t call non-procedure ' + label, this.instruction);
-        return this.resume();
+      console.error(`Can't call non-procedure ${label}`, this.instruction);
+      return this.resume();
     }
-    // istanbul ignore if
     if (def.locals.length !== this.instruction.args.length) {
-        console.error('Argument length mismatch for ' + label, this.instruction, procedure);
-        return this.resume();
+      console.error(`Argument length mismatch for ${label}`, this.instruction);
+      return this.resume();
     }
     // TODO replace this.global with closure scope if scoped procedures become
     // viable. This will require that the engine create references to closures
@@ -353,210 +420,214 @@ Engine.prototype.$call = function $call() {
     // capturing locals. As such the parser will need to retain a reference to
     // the enclosing procedure and note all of the child procedures as they are
     // encountered.
-    this.top = new Frame(this.top, def.locals, this.instruction.next, this.instruction.branch, this.label);
-    for (var i = 0; i < this.instruction.args.length; i++) {
-        var arg = this.instruction.args[i];
-        var value = evaluate(this.top.parent, this.randomer, arg);
-        this.top.set(def.locals[i], value);
+    this.top = new Frame(
+      this.top,
+      def.locals,
+      this.instruction.next,
+      this.instruction.branch,
+      this.label
+    );
+    for (let i = 0; i < this.instruction.args.length; i++) {
+      const arg = this.instruction.args[i];
+      const value = evaluate(this.top.parent, this.randomer, arg);
+      this.top.set(def.locals[i], value);
     }
     return this.goto(label);
-};
+  }
 
-Engine.prototype.$def = function $def() {
+  $def() {
     // Procedure argument instructions exist as targets for labels as well as
     // for reference to locals in calls.
     return this.goto(this.instruction.next);
-};
+  }
 
-Engine.prototype.$opt = function $opt() {
-    var closure = new Closure(this.top, this.label);
-    for (var i = 0; i < this.instruction.keywords.length; i++) {
-        var keyword = this.instruction.keywords[i];
-        // The first option to introduce a keyword wins, not the last.
-        if (!this.keywords[keyword]) {
-            this.keywords[keyword] = closure;
-        }
+  $opt() {
+    const closure = new Closure(this.top, this.label);
+    for (let i = 0; i < this.instruction.keywords.length; i++) {
+      const keyword = this.instruction.keywords[i];
+      // The first option to introduce a keyword wins, not the last.
+      if (!this.keywords[keyword]) {
+        this.keywords[keyword] = closure;
+      }
     }
     if (this.instruction.question.length > 0) {
-        this.options.push(closure);
-        this.render.startOption();
-        this.top = new Frame(this.top, [], this.instruction.next, 'RET', this.label, true);
-        return this.gothrough(this.instruction.question, 'RET');
+      this.options.push(closure);
+      this.render.startOption();
+      this.top = new Frame(this.top, [], this.instruction.next, 'RET', this.label, true);
+      return this.gothrough(this.instruction.question, 'RET');
     } else if (this.noOption == null) {
-        this.noOption = closure;
+      this.noOption = closure;
     }
     return this.goto(this.instruction.next);
-};
+  }
 
-Engine.prototype.$move = function $move() {
-    var value = evaluate(this.top, this.randomer, this.instruction.source);
-    var name = evaluate.nominate(this.top, this.randomer, this.instruction.target);
-    // istanbul ignore if
+  $move() {
+    const value = evaluate(this.top, this.randomer, this.instruction.source);
+    const name = evaluate.nominate(this.top, this.randomer, this.instruction.target);
     if (this.debug) {
-        console.log(this.top.at() + '/' + this.label + ' ' + name + ' = ' + value);
+      console.log(`${this.top.at()}/${this.label} ${name} = ${value}`);
     }
     this.top.set(name, value);
     return this.goto(this.instruction.next);
-};
+  }
 
-Engine.prototype.$jump = function $jump() {
-    var j = this.instruction;
+  $jump() {
+    const j = this.instruction;
     if (evaluate(this.top, this.randomer, j.condition)) {
-        return this.goto(this.instruction.branch);
+      return this.goto(this.instruction.branch);
     } else {
-        return this.goto(this.instruction.next);
+      return this.goto(this.instruction.next);
     }
-};
+  }
 
-Engine.prototype.$switch = function $switch() {
-    var branches = this.instruction.branches.slice();
-    var weightExpressions = this.instruction.weights.slice();
-    var samples = 1;
-    var nexts = [];
+  $switch() {
+    const branches = this.instruction.branches.slice();
+    const weightExpressions = this.instruction.weights.slice();
+    let samples = 1;
+    const nexts = [];
     if (this.instruction.mode === 'pick') {
-        samples = evaluate(this.top, this.randomer, this.instruction.expression);
-    }
-    for (var i = 0; i < samples; i++) {
-        var value;
-        var weights = [];
-        var weight = weigh(this.top, this.randomer, weightExpressions, weights);
-        if (this.instruction.mode === 'rand' || this.instruction.mode === 'pick') {
-            if (weights.length === weight) {
-                value = Math.floor(this.randomer.random() * branches.length);
-            } else {
-                value = pick(weights, weight, this.randomer);
-                if (value == null) {
-                    break;
-                }
-            }
+      samples = evaluate(this.top, this.randomer, this.instruction.expression);
+    }
+    let value, next;
+    for (let i = 0; i < samples; i++) {
+      const weights = [];
+      const weight = weigh(this.top, this.randomer, weightExpressions, weights);
+      if (this.instruction.mode === 'rand' || this.instruction.mode === 'pick') {
+        if (weights.length === weight) {
+          value = Math.floor(this.randomer.random() * branches.length);
         } else {
-            value = evaluate(this.top, this.randomer, this.instruction.expression);
-            if (this.instruction.variable != null) {
-                this.top.set(this.instruction.variable, value + this.instruction.value);
-            }
+          value = pick(weights, weight, this.randomer);
+          if (value == null) {
+            break;
+          }
         }
-        if (this.instruction.mode === 'loop') {
-            // actual modulo, wraps negatives
-            value = ((value % branches.length) + branches.length) % branches.length;
-        } else if (this.instruction.mode === 'hash') {
-            value = evaluate.hash(value) % branches.length;
+      } else {
+        value = evaluate(this.top, this.randomer, this.instruction.expression);
+        if (this.instruction.variable != null) {
+          this.top.set(this.instruction.variable, value + this.instruction.value);
         }
-        value = Math.min(value, branches.length - 1);
-        value = Math.max(value, 0);
-        var next = branches[value];
-        pop(branches, value);
-        pop(weightExpressions, value);
-        nexts.push(next);
-    }
-    // istanbul ignore if
+      }
+      if (this.instruction.mode === 'loop') {
+        // actual modulo, wraps negatives
+        value = ((value % branches.length) + branches.length) % branches.length;
+      } else if (this.instruction.mode === 'hash') {
+        value = evaluate.hash(value) % branches.length;
+      }
+      value = Math.min(value, branches.length - 1);
+      value = Math.max(value, 0);
+      next = branches[value];
+      pop(branches, value);
+      pop(weightExpressions, value);
+      nexts.push(next);
+    }
     if (this.debug) {
-        console.log(this.top.at() + '/' + this.label + ' ' + value + ' -> ' + next);
+      console.log(`${this.top.at()}/${this.label} ${value} -> ${next}`);
     }
     return this.gothrough(nexts, this.instruction.next);
-};
+  }
 
-Engine.prototype.$cue = function $cue() {
+  $cue() {
     if (this.handler != null && this.handler.cue != null) {
-        return this.handler.cue(this.instruction.cue, this.instruction.next, this);
+      return this.handler.cue(this.instruction.cue, this.instruction.next, this);
     } else {
-        return this.goto(this.instruction.next);
-    }
-};
-
-function weigh(scope, randomer, expressions, weights) {
-    var weight = 0;
-    for (var i = 0; i < expressions.length; i++) {
-        weights[i] = evaluate(scope, randomer, expressions[i]);
-        weight += weights[i];
-    }
-    return weight;
-}
-
-function pick(weights, weight, randomer) {
-    var offset = Math.floor(randomer.random() * weight);
-    var passed = 0;
-    for (var i = 0; i < weights.length; i++) {
-        passed += weights[i];
-        if (offset < passed) {
-            return i;
-        }
+      return this.goto(this.instruction.next);
     }
-    return null;
-}
-
-function pop(array, index) {
-    array[index] = array[array.length - 1];
-    array.length--;
-}
+  }
 
-Engine.prototype.$ask = function $ask() {
+  $ask() {
     this.ask();
     return false;
-};
+  }
 
-Engine.prototype.$read = function $read() {
+  $read() {
     this.read();
     return false;
-};
+  }
+}
 
-function Global(handler) {
+class Global {
+  constructor(handler) {
     this.scope = Object.create(null);
     this.handler = handler;
     this.next = 'RET';
     this.branch = 'RET';
     Object.seal(this);
-}
+  }
 
-Global.prototype.get = function get(name) {
+  get(name) {
     if (this.handler && this.handler.has && this.handler.has(name)) {
-        return this.handler.get(name);
+      return this.handler.get(name);
     } else {
-        return this.scope[name] || 0;
+      return this.scope[name] || 0;
     }
-};
+  }
 
-Global.prototype.set = function set(name, value) {
+  set(name, value) {
     if (this.handler && this.handler.has && this.handler.has(name)) {
-        this.handler.set(name, value);
+      this.handler.set(name, value);
     } else {
-        this.scope[name] = value;
+      this.scope[name] = value;
     }
     if (this.handler && this.handler.changed) {
-        this.handler.changed(name, value);
+      this.handler.changed(name, value);
     }
-};
+  }
 
-// istanbul ignore next
-Global.prototype.log = function log() {
-    var names = Object.keys(this.scope);
+  log() {
+    const names = Object.keys(this.scope);
     names.sort();
-    for (var i = 0; i < names.length; i++) {
-        var name = names[i];
-        var value = this.scope[name];
-        console.log(name + ' = ' + value);
+    for (let i = 0; i < names.length; i++) {
+      const name = names[i];
+      const value = this.scope[name];
+      console.log(`${name} = ${value}`);
     }
     console.log('');
-};
+  }
 
-// istanbul ignore next
-Global.prototype.at = function at() {
+  at() {
     return '';
-};
+  }
 
-Global.prototype.capture = function () {
-    var names = Object.keys(this.scope);
-    var values = [];
-    for (var i = 0; i < names.length; i++) {
-        values[i] = this.scope[names[i]] || 0;
+  capture() {
+    const names = Object.keys(this.scope);
+    const values = [];
+    for (let i = 0; i < names.length; i++) {
+      values[i] = this.scope[names[i]] || 0;
     }
     return [names, values];
-};
+  }
+}
+
+class Frame {
+  static restore(engine, snapshot, parent) {
+    const label = engine.labelOfIndex(snapshot[0]);
+    const next = engine.labelOfIndex(snapshot[1]);
+    const branch = engine.labelOfIndex(snapshot[2]);
+    const values = snapshot[3];
+    const stopOption = Boolean(snapshot[4]);
+
+    const frame = new Frame(parent, [], next, branch, label, stopOption);
 
-function Frame(parent, locals, next, branch, label, stopOption) {
+    // Technically, not all frames correspond to subroutine calls, but all
+    // frames that remain when the engine pauses ought to be.
+    // The exceptions would be interstitial frames generated by gothrough,
+    // but all of these are exhausted before the engine stops to ask a prompt.
+    const call = engine.story[label];
+    const def = engine.story[call.label];
+    frame.locals = def.locals;
+    for (let i = 0; i < values.length; i++) {
+      const name = def.locals[i];
+      frame.scope[name] = values[i];
+    }
+
+    return frame;
+  }
+
+  constructor(parent, locals, next, branch, label, stopOption) {
     this.locals = locals;
     this.scope = Object.create(null);
-    for (var i = 0; i < locals.length; i++) {
-        this.scope[locals[i]] = 0;
+    for (let i = 0; i < locals.length; i++) {
+      this.scope[locals[i]] = 0;
     }
     this.parent = parent;
     this.next = next;
@@ -564,100 +635,58 @@ function Frame(parent, locals, next, branch, label, stopOption) {
     this.label = label;
     this.stopOption = stopOption || false;
     Object.seal(this);
-}
+  }
 
-Frame.prototype.get = function get(name) {
+  get(name) {
     if (this.locals.indexOf(name) >= 0) {
-        return this.scope[name];
+      return this.scope[name];
     }
     return this.parent.get(name);
-};
+  }
 
-Frame.prototype.set = function set(name, value) {
-    // istanbul ignore else
+  set(name, value) {
     if (this.locals.indexOf(name) >= 0) {
-        this.scope[name] = value;
-        return;
+      this.scope[name] = value;
+      return;
     }
     this.parent.set(name, value);
-};
+  }
 
-// istanbul ignore next
-Frame.prototype.log = function log() {
+  log() {
     this.parent.log();
-    console.log('--- ' + this.label + ' -> ' + this.next);
-    for (var i = 0; i < this.locals.length; i++) {
-        var name = this.locals[i];
-        var value = this.scope[name];
-        console.log(name + ' = ' + value);
+    console.log(`--- ${this.label} -> ${this.next}`);
+    for (let i = 0; i < this.locals.length; i++) {
+      const name = this.locals[i];
+      const value = this.scope[name];
+      console.log(`${name} = ${value}`);
     }
-};
+  }
 
-// istanbul ignore next
-Frame.prototype.at = function at() {
-    return this.parent.at() + '/' + this.label;
-};
+  at() {
+    return `${this.parent.at()}/${this.label}`;
+  }
 
-Frame.prototype.capture = function capture(engine) {
-    var values = [];
-    for (var i = 0; i < this.locals.length; i++) {
-        var local = this.locals[i];
-        values.push(this.scope[local] || 0);
+  capture(engine) {
+    const values = [];
+    for (let i = 0; i < this.locals.length; i++) {
+      const local = this.locals[i];
+      values.push(this.scope[local] || 0);
     }
 
     return [
-        engine.indexOfLabel(this.label),
-        engine.indexOfLabel(this.next),
-        engine.indexOfLabel(this.branch),
-        values,
-        +this.stopOption,
+      engine.indexOfLabel(this.label),
+      engine.indexOfLabel(this.next),
+      engine.indexOfLabel(this.branch),
+      values,
+      +this.stopOption,
     ];
-};
-
-Frame.restore = function (engine, snapshot, parent) {
-    var label = engine.labelOfIndex(snapshot[0]);
-    var next = engine.labelOfIndex(snapshot[1]);
-    var branch = engine.labelOfIndex(snapshot[2]);
-    var values = snapshot[3];
-    var stopOption = Boolean(snapshot[4]);
-
-    var frame = new Frame(parent, [], next, branch, label, stopOption);
-
-    // Technically, not all frames correspond to subroutine calls, but all
-    // frames that remain when the engine pauses ought to be.
-    // The exceptions would be interstitial frames generated by gothrough,
-    // but all of these are exhausted before the engine stops to ask a prompt.
-    var call = engine.story[label];
-    var def = engine.story[call.label];
-    frame.locals = def.locals;
-    for (var i = 0; i < values.length; i++) {
-        var name = def.locals[i];
-        frame.scope[name] = values[i];
-    }
-
-    return frame;
-};
-
-Engine.prototype.labelOfIndex = function (index) {
-    if (index == -2) {
-        return 'RET';
-    } else if (index === -3) {
-        return 'ESC';
-    }
-    return this.labels[index];
-};
-
-Engine.prototype.indexOfLabel = function (label) {
-    if (label === 'RET') {
-        return -2;
-    } else if (label === 'ESC') {
-        return -3;
-    }
-    return this.labels.indexOf(label);
-};
+  }
+}
 
-function Closure(scope, label) {
+class Closure {
+  constructor(scope, label) {
     this.scope = scope;
     this.label = label;
     Object.seal(this);
+  }
 }