jssm.es5.js

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.weighted_histo_key = exports.weighted_sample_select = exports.histograph = exports.weighted_rand_select = exports.seq = exports.arrow_right_kind = exports.arrow_left_kind = exports.arrow_direction = exports.sm = exports.compile = exports.parse = exports.make = exports.Machine = exports.transfer_state_properties = exports.version = undefined;

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _jssmUtil = require('./jssm-util.js');

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }

// whargarbl lots of these return arrays could/should be sets

var reduce_to_639 = require('reduce-to-639-1').reduce;

var parse = require('./jssm-dot.js').parse; // eslint-disable-line flowtype/no-weak-types // todo whargarbl remove any

var version = '5.12.0'; // replaced from package.js in build


/* eslint-disable complexity */

function arrow_direction(arrow) {

  switch (String(arrow)) {

    case '->':case '→':
    case '=>':case '⇒':
    case '~>':case '↛':
      return 'right';

    case '<-':case '←':
    case '<=':case '⇐':
    case '<~':case '↚':
      return 'left';

    case '<->':case '↔':
    case '<-=>':case '←⇒':
    case '<-~>':case '←↛':

    case '<=>':case '⇔':
    case '<=->':case '⇐→':
    case '<=~>':case '⇐↛':

    case '<~>':case '↮':
    case '<~->':case '↚→':
    case '<~=>':case '↚⇒':
      return 'both';

    default:
      throw new Error('arrow_direction: unknown arrow type ' + arrow);

  }
}

/* eslint-enable complexity */

/* eslint-disable complexity */

function arrow_left_kind(arrow) {

  switch (String(arrow)) {

    case '->':case '→':
    case '=>':case '⇒':
    case '~>':case '↛':
      return 'none';

    case '<-':case '←':
    case '<->':case '↔':
    case '<-=>':case '←⇒':
    case '<-~>':case '←↛':
      return 'legal';

    case '<=':case '⇐':
    case '<=>':case '⇔':
    case '<=->':case '⇐→':
    case '<=~>':case '⇐↛':
      return 'main';

    case '<~':case '↚':
    case '<~>':case '↮':
    case '<~->':case '↚→':
    case '<~=>':case '↚⇒':
      return 'forced';

    default:
      throw new Error('arrow_direction: unknown arrow type ' + arrow);

  }
}

/* eslint-enable complexity */

/* eslint-disable complexity */

function arrow_right_kind(arrow) {

  switch (String(arrow)) {

    case '<-':case '←':
    case '<=':case '⇐':
    case '<~':case '↚':
      return 'none';

    case '->':case '→':
    case '<->':case '↔':
    case '<=->':case '⇐→':
    case '<~->':case '↚→':
      return 'legal';

    case '=>':case '⇒':
    case '<=>':case '⇔':
    case '<-=>':case '←⇒':
    case '<~=>':case '↚⇒':
      return 'main';

    case '~>':case '↛':
    case '<~>':case '↮':
    case '<-~>':case '←↛':
    case '<=~>':case '⇐↛':
      return 'forced';

    default:
      throw new Error('arrow_direction: unknown arrow type ' + arrow);

  }
}

/* eslint-enable complexity */

function compile_rule_transition_step(acc, from, to, this_se, next_se) {
  // todo flow describe the parser representation of a transition step extension

  var edges = [];

  var uFrom = Array.isArray(from) ? from : [from],
      uTo = Array.isArray(to) ? to : [to];

  uFrom.map(function (f) {
    uTo.map(function (t) {

      var rk = arrow_right_kind(this_se.kind),
          lk = arrow_left_kind(this_se.kind);

      var right = {
        from: f,
        to: t,
        kind: rk,
        forced_only: rk === 'forced',
        main_path: rk === 'main'
      };

      if (this_se.r_action) {
        right.action = this_se.r_action;
      }
      if (this_se.r_probability) {
        right.probability = this_se.r_probability;
      }
      if (right.kind !== 'none') {
        edges.push(right);
      }

      var left = {
        from: t,
        to: f,
        kind: lk,
        forced_only: lk === 'forced',
        main_path: lk === 'main'
      };

      if (this_se.l_action) {
        left.action = this_se.l_action;
      }
      if (this_se.l_probability) {
        left.probability = this_se.l_probability;
      }
      if (left.kind !== 'none') {
        edges.push(left);
      }
    });
  });

  var new_acc = acc.concat(edges);

  if (next_se) {
    return compile_rule_transition_step(new_acc, to, next_se.to, next_se, next_se.se);
  } else {
    return new_acc;
  }
}

function compile_rule_handle_transition(rule) {
  // todo flow describe the parser representation of a transition
  return compile_rule_transition_step([], rule.from, rule.se.to, rule.se, rule.se.se);
}

function compile_rule_handler(rule) {
  // todo flow describe the output of the parser

  if (rule.key === 'transition') {
    return { agg_as: 'transition', val: compile_rule_handle_transition(rule) };
  }

  if (rule.key === 'machine_language') {
    return { agg_as: 'machine_language', val: reduce_to_639(rule.value) };
  }

  if (rule.key === 'state_declaration') {
    if (!rule.name) {
      throw new Error('State declarations must have a name');
    }
    return { agg_as: 'state_declaration', val: { state: rule.name, declarations: rule.value } };
  }

  var tautologies = ['graph_layout', 'start_states', 'end_states', 'machine_name', 'machine_version', 'machine_comment', 'machine_author', 'machine_contributor', 'machine_definition', 'machine_reference', 'machine_license', 'fsl_version'];

  if (tautologies.includes(rule.key)) {
    return { agg_as: rule.key, val: rule.value };
  }

  throw new Error('compile_rule_handler: Unknown rule: ' + JSON.stringify(rule));
}

function compile(tree) {
  var _ref;

  // todo flow describe the output of the parser

  var results = {
    graph_layout: [],
    transition: [],
    start_states: [],
    end_states: [],
    state_declaration: [],
    fsl_version: [],
    machine_author: [],
    machine_comment: [],
    machine_contributor: [],
    machine_definition: [],
    machine_language: [],
    machine_license: [],
    machine_name: [],
    machine_reference: [],
    machine_version: []
  };

  tree.map(function (tr) {

    var rule = compile_rule_handler(tr),
        agg_as = rule.agg_as,
        val = rule.val; // todo better types

    results[agg_as] = results[agg_as].concat(val);
  });

  var assembled_transitions = (_ref = []).concat.apply(_ref, _toConsumableArray(results['transition']));

  var result_cfg = {
    start_states: results.start_states.length ? results.start_states : [assembled_transitions[0].from],
    transitions: assembled_transitions
  };

  var oneOnlyKeys = ['graph_layout', 'machine_name', 'machine_version', 'machine_comment', 'fsl_version', 'machine_license', 'machine_definition', 'machine_language'];

  oneOnlyKeys.map(function (oneOnlyKey) {
    if (results[oneOnlyKey].length > 1) {
      throw new Error('May only have one ' + oneOnlyKey + ' statement maximum: ' + JSON.stringify(results[oneOnlyKey]));
    } else {
      if (results[oneOnlyKey].length) {
        result_cfg[oneOnlyKey] = results[oneOnlyKey][0];
      }
    }
  });

  ['machine_author', 'machine_contributor', 'machine_reference', 'state_declaration'].map(function (multiKey) {
    if (results[multiKey].length) {
      result_cfg[multiKey] = results[multiKey];
    }
  });

  return result_cfg;
}

function make(plan) {
  return compile(parse(plan));
}

function transfer_state_properties(state_decl) {

  state_decl.declarations.map(function (d) {
    switch (d.key) {

      case 'node_shape':
        state_decl.node_shape = d.value;break;
      case 'node_color':
        state_decl.node_color = d.value;break;

      default:
        throw new Error('Unknown state property: \'' + JSON.stringify(d) + '\'');

    }
  });

  return state_decl;
}

var Machine = function () {

  // whargarbl this badly needs to be broken up, monolith master
  // eslint-disable-line flowtype/no-weak-types
  function Machine(_ref2) {
    var _this = this;

    var start_states = _ref2.start_states,
        _ref2$complete = _ref2.complete,
        complete = _ref2$complete === undefined ? [] : _ref2$complete,
        transitions = _ref2.transitions,
        machine_author = _ref2.machine_author,
        machine_comment = _ref2.machine_comment,
        machine_contributor = _ref2.machine_contributor,
        machine_definition = _ref2.machine_definition,
        machine_language = _ref2.machine_language,
        machine_license = _ref2.machine_license,
        machine_name = _ref2.machine_name,
        machine_version = _ref2.machine_version,
        state_declaration = _ref2.state_declaration,
        fsl_version = _ref2.fsl_version,
        _ref2$graph_layout = _ref2.graph_layout,
        graph_layout = _ref2$graph_layout === undefined ? 'dot' : _ref2$graph_layout;

    _classCallCheck(this, Machine);

    this._state = start_states[0];
    this._states = new Map();
    this._state_declarations = new Map();
    this._edges = [];
    this._edge_map = new Map();
    this._named_transitions = new Map();
    this._actions = new Map();
    this._reverse_actions = new Map();
    this._reverse_action_targets = new Map(); // todo

    this._machine_author = machine_author;
    this._machine_comment = machine_comment;
    this._machine_contributor = machine_contributor;
    this._machine_definition = machine_definition;
    this._machine_language = machine_language;
    this._machine_license = machine_license;
    this._machine_name = machine_name;
    this._machine_version = machine_version;
    this._raw_state_declaration = state_declaration || [];
    this._fsl_version = fsl_version;

    this._graph_layout = graph_layout;

    if (state_declaration) {
      state_declaration.map(function (state_decl) {

        if (_this._state_declarations.has(state_decl.state)) {
          // no repeats
          throw new Error('Added the same state declaration twice: ' + JSON.stringify(state_decl.state));
        }

        _this._state_declarations.set(state_decl.state, transfer_state_properties(state_decl));
      });
    }

    transitions.map(function (tr) {

      if (tr.from === undefined) {
        throw new Error('transition must define \'from\': ' + JSON.stringify(tr));
      }
      if (tr.to === undefined) {
        throw new Error('transition must define \'to\': ' + JSON.stringify(tr));
      }

      // get the cursors.  what a mess
      var cursor_from = _this._states.get(tr.from) || { name: tr.from, from: [], to: [], complete: complete.includes(tr.from) };

      if (!_this._states.has(tr.from)) {
        _this._new_state(cursor_from);
      }

      var cursor_to = _this._states.get(tr.to) || { name: tr.to, from: [], to: [], complete: complete.includes(tr.to) };

      if (!_this._states.has(tr.to)) {
        _this._new_state(cursor_to);
      }

      // guard against existing connections being re-added
      if (cursor_from.to.includes(tr.to)) {
        throw new Error('already has ' + JSON.stringify(tr.from) + ' to ' + JSON.stringify(tr.to));
      } else {
        cursor_from.to.push(tr.to);
        cursor_to.from.push(tr.from);
      }

      // add the edge; note its id
      _this._edges.push(tr);
      var thisEdgeId = _this._edges.length - 1;

      // guard against repeating a transition name
      if (tr.name) {
        if (_this._named_transitions.has(tr.name)) {
          throw new Error('named transition "' + JSON.stringify(tr.name) + '" already created');
        } else {
          _this._named_transitions.set(tr.name, thisEdgeId);
        }
      }

      // set up the mapping, so that edges can be looked up by endpoint pairs
      var from_mapping = _this._edge_map.get(tr.from) || new Map();
      if (!_this._edge_map.has(tr.from)) {
        _this._edge_map.set(tr.from, from_mapping);
      }

      //    const to_mapping = from_mapping.get(tr.to);
      from_mapping.set(tr.to, thisEdgeId); // already checked that this mapping doesn't exist, above

      // set up the action mapping, so that actions can be looked up by origin
      if (tr.action) {

        // forward mapping first by action name
        var actionMap = _this._actions.get(tr.action);
        if (!actionMap) {
          actionMap = new Map();
          _this._actions.set(tr.action, actionMap);
        }

        if (actionMap.has(tr.from)) {
          throw new Error('action ' + JSON.stringify(tr.action) + ' already attached to origin ' + JSON.stringify(tr.from));
        } else {
          actionMap.set(tr.from, thisEdgeId);
        }

        // reverse mapping first by state origin name
        var rActionMap = _this._reverse_actions.get(tr.from);
        if (!rActionMap) {
          rActionMap = new Map();
          _this._reverse_actions.set(tr.from, rActionMap);
        }

        // no need to test for reverse mapping pre-presence;
        // forward mapping already covers collisions
        rActionMap.set(tr.action, thisEdgeId);

        // reverse mapping first by state target name
        if (!_this._reverse_action_targets.has(tr.to)) {
          _this._reverse_action_targets.set(tr.to, new Map());
        }

        /* todo comeback
           fundamental problem is roActionMap needs to be a multimap
                const roActionMap = this._reverse_action_targets.get(tr.to);  // wasteful - already did has - refactor
                if (roActionMap) {
                  if (roActionMap.has(tr.action)) {
                    throw new Error(`ro-action ${tr.to} already attached to action ${tr.action}`);
                  } else {
                    roActionMap.set(tr.action, thisEdgeId);
                  }
                } else {
                  throw new Error('should be impossible - flow doesn\'t know .set precedes .get yet again.  severe error?');
                }
        */
      }
    });
  }

  _createClass(Machine, [{
    key: '_new_state',
    value: function _new_state(state_config) {
      // whargarbl get that state_config any under control

      if (this._states.has(state_config.name)) {
        throw new Error('state ' + JSON.stringify(state_config.name) + ' already exists');
      }

      this._states.set(state_config.name, state_config);
      return state_config.name;
    }
  }, {
    key: 'state',
    value: function state() {
      return this._state;
    }

    /* whargarbl todo major
       when we reimplement this, reintroduce this change to the is_final call
    
      is_changing(): boolean {
        return true; // todo whargarbl
      }
    */

  }, {
    key: 'state_is_final',
    value: function state_is_final(whichState) {
      return this.state_is_terminal(whichState) && this.state_is_complete(whichState);
    }
  }, {
    key: 'is_final',
    value: function is_final() {
      //  return ((!this.is_changing()) && this.state_is_final(this.state()));
      return this.state_is_final(this.state());
    }
  }, {
    key: 'graph_layout',
    value: function graph_layout() {
      return this._graph_layout;
    }
  }, {
    key: 'machine_author',
    value: function machine_author() {
      return this._machine_author;
    }
  }, {
    key: 'machine_comment',
    value: function machine_comment() {
      return this._machine_comment;
    }
  }, {
    key: 'machine_contributor',
    value: function machine_contributor() {
      return this._machine_contributor;
    }
  }, {
    key: 'machine_definition',
    value: function machine_definition() {
      return this._machine_definition;
    }
  }, {
    key: 'machine_language',
    value: function machine_language() {
      return this._machine_language;
    }
  }, {
    key: 'machine_license',
    value: function machine_license() {
      return this._machine_license;
    }
  }, {
    key: 'machine_name',
    value: function machine_name() {
      return this._machine_name;
    }
  }, {
    key: 'machine_version',
    value: function machine_version() {
      return this._machine_version;
    }
  }, {
    key: 'raw_state_declarations',
    value: function raw_state_declarations() {
      // eslint-disable-line flowtype/no-weak-types
      return this._raw_state_declaration;
    }
  }, {
    key: 'state_declaration',
    value: function state_declaration(which) {
      return this._state_declarations.get(which);
    }
  }, {
    key: 'state_declarations',
    value: function state_declarations() {
      // eslint-disable-line flowtype/no-weak-types
      return this._state_declarations;
    }
  }, {
    key: 'fsl_version',
    value: function fsl_version() {
      return this._fsl_version;
    }
  }, {
    key: 'machine_state',
    value: function machine_state() {

      return {
        internal_state_impl_version: 1,

        actions: this._actions,
        edge_map: this._edge_map,
        edges: this._edges,
        named_transitions: this._named_transitions,
        reverse_actions: this._reverse_actions,
        //    reverse_action_targets : this._reverse_action_targets,
        state: this._state,
        states: this._states
      };
    }

    /*
      load_machine_state(): boolean {
        return false; // todo whargarbl
      }
    */

  }, {
    key: 'states',
    value: function states() {
      return [].concat(_toConsumableArray(this._states.keys()));
    }
  }, {
    key: 'state_for',
    value: function state_for(whichState) {
      var state = this._states.get(whichState);
      if (state) {
        return state;
      } else {
        throw new Error('no such state ' + JSON.stringify(state));
      }
    }
  }, {
    key: 'list_edges',
    value: function list_edges() {
      return this._edges;
    }
  }, {
    key: 'list_named_transitions',
    value: function list_named_transitions() {
      return this._named_transitions;
    }
  }, {
    key: 'list_actions',
    value: function list_actions() {
      return [].concat(_toConsumableArray(this._actions.keys()));
    }
  }, {
    key: 'get_transition_by_state_names',
    value: function get_transition_by_state_names(from, to) {

      var emg = this._edge_map.get(from);

      if (emg) {
        return emg.get(to);
      } else {
        return undefined;
      }
    }
  }, {
    key: 'lookup_transition_for',
    value: function lookup_transition_for(from, to) {
      var id = this.get_transition_by_state_names(from, to);
      return id === undefined || id === null ? undefined : this._edges[id];
    }
  }, {
    key: 'list_transitions',
    value: function list_transitions() {
      var whichState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state();

      return { entrances: this.list_entrances(whichState), exits: this.list_exits(whichState) };
    }
  }, {
    key: 'list_entrances',
    value: function list_entrances() {
      var whichState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state();

      return (this._states.get(whichState) || {}).from || [];
    }
  }, {
    key: 'list_exits',
    value: function list_exits() {
      var whichState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state();

      return (this._states.get(whichState) || {}).to || [];
    }
  }, {
    key: 'probable_exits_for',
    value: function probable_exits_for(whichState) {
      var _this2 = this;

      var wstate = this._states.get(whichState);
      if (!wstate) {
        throw new Error('No such state ' + JSON.stringify(whichState) + ' in probable_exits_for');
      }

      var wstate_to = wstate.to,
          wtf // wstate_to_filtered -> wtf
      = wstate_to.map(function (ws) {
        return _this2.lookup_transition_for(_this2.state(), ws);
      }).filter(Boolean);

      return wtf;
    }
  }, {
    key: 'probabilistic_transition',
    value: function probabilistic_transition() {
      var selected = (0, _jssmUtil.weighted_rand_select)(this.probable_exits_for(this.state()));
      return this.transition(selected.to);
    }
  }, {
    key: 'probabilistic_walk',
    value: function probabilistic_walk(n) {
      var _this3 = this;

      return (0, _jssmUtil.seq)(n).map(function () {
        var state_was = _this3.state();
        _this3.probabilistic_transition();
        return state_was;
      }).concat([this.state()]);
    }
  }, {
    key: 'probabilistic_histo_walk',
    value: function probabilistic_histo_walk(n) {
      return (0, _jssmUtil.histograph)(this.probabilistic_walk(n));
    }
  }, {
    key: 'actions',
    value: function actions() {
      var whichState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state();

      var wstate = this._reverse_actions.get(whichState);
      if (wstate) {
        return [].concat(_toConsumableArray(wstate.keys()));
      } else {
        throw new Error('No such state ' + JSON.stringify(whichState));
      }
    }
  }, {
    key: 'list_states_having_action',
    value: function list_states_having_action(whichState) {
      var wstate = this._actions.get(whichState);
      if (wstate) {
        return [].concat(_toConsumableArray(wstate.keys()));
      } else {
        throw new Error('No such state ' + JSON.stringify(whichState));
      }
    }

    // comeback
    /*
      list_entrance_actions(whichState: mNT = this.state() ) : Array<mNT> {
        return [... (this._reverse_action_targets.get(whichState) || new Map()).values()] // wasteful
               .map( (edgeId:any) => (this._edges[edgeId] : any)) // whargarbl burn out any
               .filter( (o:any) => o.to === whichState)
               .map( filtered => filtered.from );
      }
    */

  }, {
    key: 'list_exit_actions',
    value: function list_exit_actions() {
      var _this4 = this;

      var whichState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state();
      // these are mNT, not ?mNT
      var ra_base = this._reverse_actions.get(whichState);
      if (!ra_base) {
        throw new Error('No such state ' + JSON.stringify(whichState));
      }

      return [].concat(_toConsumableArray(ra_base.values())).map(function (edgeId) {
        return _this4._edges[edgeId];
      }).filter(function (o) {
        return o.from === whichState;
      }).map(function (filtered) {
        return filtered.action;
      });
    }
  }, {
    key: 'probable_action_exits',
    value: function probable_action_exits() {
      var _this5 = this;

      var whichState = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.state();
      // these are mNT
      var ra_base = this._reverse_actions.get(whichState);
      if (!ra_base) {
        throw new Error('No such state ' + JSON.stringify(whichState));
      }

      return [].concat(_toConsumableArray(ra_base.values())).map(function (edgeId) {
        return _this5._edges[edgeId];
      }).filter(function (o) {
        return o.from === whichState;
      }).map(function (filtered) {
        return { action: filtered.action,
          probability: filtered.probability };
      });
    }
  }, {
    key: 'is_unenterable',
    value: function is_unenterable(whichState) {
      // whargarbl should throw on unknown state
      return this.list_entrances(whichState).length === 0;
    }
  }, {
    key: 'has_unenterables',
    value: function has_unenterables() {
      var _this6 = this;

      return this.states().some(function (x) {
        return _this6.is_unenterable(x);
      });
    }
  }, {
    key: 'is_terminal',
    value: function is_terminal() {
      return this.state_is_terminal(this.state());
    }
  }, {
    key: 'state_is_terminal',
    value: function state_is_terminal(whichState) {
      // whargarbl should throw on unknown state
      return this.list_exits(whichState).length === 0;
    }
  }, {
    key: 'has_terminals',
    value: function has_terminals() {
      var _this7 = this;

      return this.states().some(function (x) {
        return _this7.state_is_terminal(x);
      });
    }
  }, {
    key: 'is_complete',
    value: function is_complete() {
      return this.state_is_complete(this.state());
    }
  }, {
    key: 'state_is_complete',
    value: function state_is_complete(whichState) {
      var wstate = this._states.get(whichState);
      if (wstate) {
        return wstate.complete;
      } else {
        throw new Error('No such state ' + JSON.stringify(whichState));
      }
    }
  }, {
    key: 'has_completes',
    value: function has_completes() {
      var _this8 = this;

      return this.states().some(function (x) {
        return _this8.state_is_complete(x);
      });
    }
  }, {
    key: 'action',
    value: function action(name, newData) {
      // todo whargarbl implement hooks
      // todo whargarbl implement data stuff
      // todo major incomplete whargarbl comeback
      if (this.valid_action(name, newData)) {
        var edge = this.current_action_edge_for(name);
        this._state = edge.to;
        return true;
      } else {
        return false;
      }
    }
  }, {
    key: 'transition',
    value: function transition(newState, newData) {
      // todo whargarbl implement hooks
      // todo whargarbl implement data stuff
      // todo major incomplete whargarbl comeback
      if (this.valid_transition(newState, newData)) {
        this._state = newState;
        return true;
      } else {
        return false;
      }
    }

    // can leave machine in inconsistent state.  generally do not use

  }, {
    key: 'force_transition',
    value: function force_transition(newState, newData) {
      // todo whargarbl implement hooks
      // todo whargarbl implement data stuff
      // todo major incomplete whargarbl comeback
      if (this.valid_force_transition(newState, newData)) {
        this._state = newState;
        return true;
      } else {
        return false;
      }
    }
  }, {
    key: 'current_action_for',
    value: function current_action_for(action) {
      var action_base = this._actions.get(action);
      return action_base ? action_base.get(this.state()) : undefined;
    }
  }, {
    key: 'current_action_edge_for',
    value: function current_action_edge_for(action) {
      var idx = this.current_action_for(action);
      if (idx === undefined || idx === null) {
        throw new Error('No such action ' + JSON.stringify(action));
      }
      return this._edges[idx];
    }
  }, {
    key: 'valid_action',
    value: function valid_action(action, _newData) {
      // todo comeback unignore newData
      // todo whargarbl implement hooks
      // todo whargarbl implement data stuff
      // todo major incomplete whargarbl comeback
      return this.current_action_for(action) !== undefined;
    }
  }, {
    key: 'valid_transition',
    value: function valid_transition(newState, _newData) {
      // todo comeback unignore newData
      // todo whargarbl implement hooks
      // todo whargarbl implement data stuff
      var transition_for = this.lookup_transition_for(this.state(), newState);

      if (!transition_for) {
        return false;
      }
      if (transition_for.forced_only) {
        return false;
      }

      return true;
    }
  }, {
    key: 'valid_force_transition',
    value: function valid_force_transition(newState, _newData) {
      // todo comeback unignore newData
      // todo whargarbl implement hooks
      // todo whargarbl implement data stuff
      // todo major incomplete whargarbl comeback
      return this.lookup_transition_for(this.state(), newState) !== undefined;
    }
  }]);

  return Machine;
}();

function sm(template_strings /* , arguments */) {
  var _arguments = arguments;


  // foo`a${1}b${2}c` will come in as (['a','b','c'],1,2)
  // this includes when a and c are empty strings
  // therefore template_strings will always have one more el than template_args
  // therefore map the smaller container and toss the last one on on the way out

  return new Machine(make(template_strings.reduce(

  // in general avoiding `arguments` is smart.  however with the template
  // string notation, as designed, it's not really worth the hassle

  /* eslint-disable fp/no-arguments */
  /* eslint-disable prefer-rest-params */
  function (acc, val, idx) {
    return '' + acc + _arguments[idx] + val;
  } // arguments[0] is never loaded, so args doesn't need to be gated
  /* eslint-enable  prefer-rest-params */
  /* eslint-enable  fp/no-arguments */

  )));
}

exports.version = version;
exports.transfer_state_properties = transfer_state_properties;
exports.Machine = Machine;
exports.make = make;
exports.parse = parse;
exports.compile = compile;
exports.sm = sm;
exports.arrow_direction = arrow_direction;
exports.arrow_left_kind = arrow_left_kind;
exports.arrow_right_kind = arrow_right_kind;
exports.seq = _jssmUtil.seq;
exports.weighted_rand_select = _jssmUtil.weighted_rand_select;
exports.histograph = _jssmUtil.histograph;
exports.weighted_sample_select = _jssmUtil.weighted_sample_select;
exports.weighted_histo_key = _jssmUtil.weighted_histo_key;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/js/jssm.js"],"names":["reduce_to_639","require","reduce","parse","version","arrow_direction","arrow","String","Error","arrow_left_kind","arrow_right_kind","compile_rule_transition_step","acc","from","to","this_se","next_se","edges","uFrom","Array","isArray","uTo","map","f","t","rk","kind","lk","right","forced_only","main_path","r_action","action","r_probability","probability","push","left","l_action","l_probability","new_acc","concat","se","compile_rule_handle_transition","rule","compile_rule_handler","key","agg_as","val","value","name","state","declarations","tautologies","includes","JSON","stringify","compile","tree","results","graph_layout","transition","start_states","end_states","state_declaration","fsl_version","machine_author","machine_comment","machine_contributor","machine_definition","machine_language","machine_license","machine_name","machine_reference","machine_version","tr","assembled_transitions","result_cfg","length","transitions","oneOnlyKeys","oneOnlyKey","multiKey","make","plan","transfer_state_properties","state_decl","d","node_shape","node_color","Machine","complete","_state","_states","Map","_state_declarations","_edges","_edge_map","_named_transitions","_actions","_reverse_actions","_reverse_action_targets","_machine_author","_machine_comment","_machine_contributor","_machine_definition","_machine_language","_machine_license","_machine_name","_machine_version","_raw_state_declaration","_fsl_version","_graph_layout","has","set","undefined","cursor_from","get","_new_state","cursor_to","thisEdgeId","from_mapping","actionMap","rActionMap","state_config","whichState","state_is_terminal","state_is_complete","state_is_final","which","internal_state_impl_version","actions","edge_map","named_transitions","reverse_actions","states","keys","emg","id","get_transition_by_state_names","entrances","list_entrances","exits","list_exits","wstate","wstate_to","wtf","ws","lookup_transition_for","filter","Boolean","selected","probable_exits_for","n","state_was","probabilistic_transition","probabilistic_walk","ra_base","values","edgeId","o","filtered","some","x","is_unenterable","newData","valid_action","edge","current_action_edge_for","newState","valid_transition","valid_force_transition","action_base","idx","current_action_for","_newData","transition_for","sm","template_strings","seq","weighted_rand_select","histograph","weighted_sample_select","weighted_histo_key"],"mappings":"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","file":"jssm.js","sourcesContent":["\n// whargarbl lots of these return arrays could/should be sets\n\n// @flow\n\nconst reduce_to_639 : Function = require('reduce-to-639-1').reduce;\n\n\n\n\n\nimport type {\n\n  JssmGenericState, JssmGenericConfig,\n  JssmTransition, JssmTransitionList,\n  JssmMachineInternalState,\n  JssmParseTree,\n  JssmStateDeclaration, JssmStateDeclarationRule,\n  JssmCompileSe, JssmCompileSeStart, JssmCompileRule,\n  JssmArrow, JssmArrowDirection, JssmArrowKind,\n  JssmLayout\n\n} from './jssm-types';\n\n\n\n\n\nimport { seq, weighted_rand_select, weighted_sample_select, histograph, weighted_histo_key } from './jssm-util.js';\n\nconst parse: <NT, DT>(string) => JssmParseTree<NT> = require('./jssm-dot.js').parse;  // eslint-disable-line flowtype/no-weak-types // todo whargarbl remove any\n\nconst version: null = null; // replaced from package.js in build\n\n\n\n\n\n/* eslint-disable complexity */\n\nfunction arrow_direction(arrow: JssmArrow): JssmArrowDirection {\n\n  switch ( String(arrow) ) {\n\n    case '->' :    case '→' :\n    case '=>' :    case '⇒' :\n    case '~>' :    case '↛' :\n      return 'right';\n\n    case '<-' :    case '←' :\n    case '<=' :    case '⇐' :\n    case '<~' :    case '↚' :\n      return 'left';\n\n    case '<->':    case '↔' :\n    case '<-=>':   case '←⇒' :\n    case '<-~>':   case '←↛' :\n\n    case '<=>':    case '⇔' :\n    case '<=->':   case '⇐→' :\n    case '<=~>':   case '⇐↛' :\n\n    case '<~>':    case '↮' :\n    case '<~->':   case '↚→' :\n    case '<~=>':   case '↚⇒' :\n      return 'both';\n\n    default:\n      throw new Error(`arrow_direction: unknown arrow type ${arrow}`);\n\n  }\n\n}\n\n/* eslint-enable complexity */\n\n\n\n\n\n/* eslint-disable complexity */\n\nfunction arrow_left_kind(arrow: JssmArrow): JssmArrowKind {\n\n  switch ( String(arrow) ) {\n\n    case '->' :    case '→' :\n    case '=>' :    case '⇒' :\n    case '~>' :    case '↛' :\n      return 'none';\n\n    case '<-':     case '←' :\n    case '<->':    case '↔' :\n    case '<-=>':   case '←⇒' :\n    case '<-~>':   case '←↛' :\n      return 'legal';\n\n    case '<=':     case '⇐' :\n    case '<=>':    case '⇔' :\n    case '<=->':   case '⇐→' :\n    case '<=~>':   case '⇐↛' :\n      return 'main';\n\n    case '<~':     case '↚' :\n    case '<~>':    case '↮' :\n    case '<~->':   case '↚→' :\n    case '<~=>':   case '↚⇒' :\n      return 'forced';\n\n    default:\n      throw new Error(`arrow_direction: unknown arrow type ${arrow}`);\n\n  }\n\n}\n\n/* eslint-enable complexity */\n\n\n\n\n\n/* eslint-disable complexity */\n\nfunction arrow_right_kind(arrow: JssmArrow): JssmArrowKind {\n\n  switch ( String(arrow) ) {\n\n    case '<-' :    case '←' :\n    case '<=' :    case '⇐' :\n    case '<~' :    case '↚' :\n      return 'none';\n\n    case '->' :    case '→' :\n    case '<->':    case '↔' :\n    case '<=->':   case '⇐→' :\n    case '<~->':   case '↚→' :\n      return 'legal';\n\n    case '=>' :    case '⇒' :\n    case '<=>':    case '⇔' :\n    case '<-=>':   case '←⇒' :\n    case '<~=>':   case '↚⇒' :\n      return 'main';\n\n    case '~>' :    case '↛' :\n    case '<~>':    case '↮' :\n    case '<-~>':   case '←↛' :\n    case '<=~>':   case '⇐↛' :\n      return 'forced';\n\n    default:\n      throw new Error(`arrow_direction: unknown arrow type ${arrow}`);\n\n  }\n\n}\n\n/* eslint-enable complexity */\n\n\n\n\n\nfunction compile_rule_transition_step<mNT, mDT>(\n             acc     : Array< JssmTransition<mNT, mDT> >,\n             from    : mNT,\n             to      : mNT,\n             this_se : JssmCompileSe<mNT>,\n             next_se : JssmCompileSe<mNT>\n         ) : Array< JssmTransition<mNT, mDT> > { // todo flow describe the parser representation of a transition step extension\n\n  const edges : Array< JssmTransition<mNT, mDT> > = [];\n\n  const uFrom : Array< mNT > = (Array.isArray(from)? from : [from]),\n        uTo   : Array< mNT > = (Array.isArray(to)?   to   : [to]  );\n\n  uFrom.map( (f: mNT) => {\n    uTo.map( (t: mNT) => {\n\n      const rk: JssmArrowKind = arrow_right_kind(this_se.kind),\n            lk: JssmArrowKind = arrow_left_kind(this_se.kind);\n\n\n      const right: JssmTransition<mNT, mDT> = {\n        from        : f,\n        to          : t,\n        kind        : rk,\n        forced_only : rk === 'forced',\n        main_path   : rk === 'main'\n      };\n\n      if (this_se.r_action)      { right.action      = this_se.r_action;      }\n      if (this_se.r_probability) { right.probability = this_se.r_probability; }\n      if (right.kind !== 'none') { edges.push(right); }\n\n\n      const left: JssmTransition<mNT, mDT> = {\n        from        : t,\n        to          : f,\n        kind        : lk,\n        forced_only : lk === 'forced',\n        main_path   : lk === 'main'\n      };\n\n      if (this_se.l_action)      { left.action      = this_se.l_action;      }\n      if (this_se.l_probability) { left.probability = this_se.l_probability; }\n      if (left.kind !== 'none')  { edges.push(left); }\n\n    });\n  });\n\n  const new_acc: Array< JssmTransition<mNT, mDT> > = acc.concat(edges);\n\n  if (next_se) {\n    return compile_rule_transition_step(new_acc, to, next_se.to, next_se, next_se.se);\n  } else {\n    return new_acc;\n  }\n\n}\n\n\n\nfunction compile_rule_handle_transition<mNT>(rule: JssmCompileSeStart<mNT>): mixed { // todo flow describe the parser representation of a transition\n  return compile_rule_transition_step([], rule.from, rule.se.to, rule.se, rule.se.se);\n}\n\n\n\nfunction compile_rule_handler<mNT>(rule: JssmCompileSeStart<mNT>): JssmCompileRule { // todo flow describe the output of the parser\n\n  if (rule.key === 'transition') {\n    return { agg_as: 'transition', val: compile_rule_handle_transition(rule) };\n  }\n\n  if (rule.key === 'machine_language') {\n    return { agg_as: 'machine_language', val: reduce_to_639(rule.value) };\n  }\n\n  if (rule.key === 'state_declaration') {\n    if (!rule.name) { throw new Error('State declarations must have a name'); }\n    return { agg_as: 'state_declaration', val: { state: rule.name, declarations: rule.value } };\n  }\n\n  const tautologies : Array<string> = [\n    'graph_layout', 'start_states', 'end_states', 'machine_name', 'machine_version',\n    'machine_comment', 'machine_author', 'machine_contributor', 'machine_definition',\n    'machine_reference', 'machine_license', 'fsl_version'\n  ];\n\n  if (tautologies.includes(rule.key)) {\n    return { agg_as: rule.key, val: rule.value };\n  }\n\n  throw new Error(`compile_rule_handler: Unknown rule: ${JSON.stringify(rule)}`);\n\n}\n\n\n\n\n\nfunction compile<mNT, mDT>(tree: JssmParseTree<mNT>): JssmGenericConfig<mNT, mDT> {  // todo flow describe the output of the parser\n\n  const results : {\n    graph_layout        : Array< JssmLayout >,\n    transition          : Array< JssmTransition<mNT, mDT> >,\n    start_states        : Array< mNT >,\n    end_states          : Array< mNT >,\n    state_declaration   : Array< mNT >,\n    fsl_version         : Array< string >,\n    machine_author      : Array< string >,\n    machine_comment     : Array< string >,\n    machine_contributor : Array< string >,\n    machine_definition  : Array< string >,\n    machine_language    : Array< string >,\n    machine_license     : Array< string >,\n    machine_name        : Array< string >,\n    machine_reference   : Array< string >,\n    machine_version     : Array< string > // semver\n  } = {\n    graph_layout        : [],\n    transition          : [],\n    start_states        : [],\n    end_states          : [],\n    state_declaration   : [],\n    fsl_version         : [],\n    machine_author      : [],\n    machine_comment     : [],\n    machine_contributor : [],\n    machine_definition  : [],\n    machine_language    : [],\n    machine_license     : [],\n    machine_name        : [],\n    machine_reference   : [],\n    machine_version     : []\n  };\n\n  tree.map( (tr : JssmCompileSeStart<mNT>) => {\n\n    const rule   : JssmCompileRule = compile_rule_handler(tr),\n          agg_as : string          = rule.agg_as,\n          val    : mixed           = rule.val;                  // todo better types\n\n    results[agg_as] = results[agg_as].concat(val);\n\n  });\n\n  const assembled_transitions : Array< JssmTransition<mNT, mDT> > = [].concat(... results['transition']);\n\n  const result_cfg : JssmGenericConfig<mNT, mDT> = {\n    start_states : results.start_states.length? results.start_states : [assembled_transitions[0].from],\n    transitions  : assembled_transitions\n  };\n\n  const oneOnlyKeys : Array<string> = [\n    'graph_layout', 'machine_name', 'machine_version', 'machine_comment', 'fsl_version', 'machine_license',\n    'machine_definition', 'machine_language'\n  ];\n\n  oneOnlyKeys.map( (oneOnlyKey : string) => {\n    if (results[oneOnlyKey].length > 1) {\n      throw new Error(`May only have one ${oneOnlyKey} statement maximum: ${JSON.stringify(results[oneOnlyKey])}`);\n    } else {\n      if (results[oneOnlyKey].length) {\n        result_cfg[oneOnlyKey] = results[oneOnlyKey][0];\n      }\n    }\n  });\n\n  ['machine_author', 'machine_contributor', 'machine_reference', 'state_declaration'].map( (multiKey : string) => {\n    if (results[multiKey].length) {\n      result_cfg[multiKey] = results[multiKey];\n    }\n  });\n\n  return result_cfg;\n\n}\n\n\n\n\n\nfunction make<mNT, mDT>(plan: string): JssmGenericConfig<mNT, mDT> {\n  return compile(parse(plan));\n}\n\n\n\n\n\nfunction transfer_state_properties<mNT>(state_decl: JssmStateDeclaration<mNT>): JssmStateDeclaration<mNT> {\n\n    state_decl.declarations.map( (d: JssmStateDeclarationRule) => {\n      switch (d.key) {\n\n        case 'node_shape' : state_decl.node_shape = d.value; break;\n        case 'node_color' : state_decl.node_color = d.value; break;\n\n        default: throw new Error(`Unknown state property: '${JSON.stringify(d)}'`);\n\n      }\n    });\n\n    return state_decl;\n\n}\n\n\n\n\n\nclass Machine<mNT, mDT> {\n\n\n  _state                  : mNT;\n  _states                 : Map<mNT, JssmGenericState<mNT>>;\n  _edges                  : Array<JssmTransition<mNT, mDT>>;\n  _edge_map               : Map<mNT, Map<mNT, number>>;\n  _named_transitions      : Map<mNT, number>;\n  _actions                : Map<mNT, Map<mNT, number>>;\n  _reverse_actions        : Map<mNT, Map<mNT, number>>;\n  _reverse_action_targets : Map<mNT, Map<mNT, number>>;\n\n  _machine_author         : ?Array<string>;\n  _machine_comment        : ?string;\n  _machine_contributor    : ?Array<string>;\n  _machine_definition     : ?string;\n  _machine_language       : ?string;\n  _machine_license        : ?string;\n  _machine_name           : ?string;\n  _machine_version        : ?string;\n  _fsl_version            : ?string;\n  _raw_state_declaration  : ?Array<Object>;    // eslint-disable-line flowtype/no-weak-types\n  _state_declarations     : Map<mNT, JssmStateDeclaration<mNT>>;\n\n  _graph_layout           : JssmLayout;\n\n\n  // whargarbl this badly needs to be broken up, monolith master\n  constructor({\n    start_states,\n    complete        = [],\n    transitions,\n    machine_author,\n    machine_comment,\n    machine_contributor,\n    machine_definition,\n    machine_language,\n    machine_license,\n    machine_name,\n    machine_version,\n    state_declaration,\n    fsl_version,\n    graph_layout = 'dot'\n  } : JssmGenericConfig<mNT, mDT>) {\n\n    this._state                  = start_states[0];\n    this._states                 = new Map();\n    this._state_declarations     = new Map();\n    this._edges                  = [];\n    this._edge_map               = new Map();\n    this._named_transitions      = new Map();\n    this._actions                = new Map();\n    this._reverse_actions        = new Map();\n    this._reverse_action_targets = new Map();   // todo\n\n    this._machine_author         = machine_author;\n    this._machine_comment        = machine_comment;\n    this._machine_contributor    = machine_contributor;\n    this._machine_definition     = machine_definition;\n    this._machine_language       = machine_language;\n    this._machine_license        = machine_license;\n    this._machine_name           = machine_name;\n    this._machine_version        = machine_version;\n    this._raw_state_declaration  = state_declaration || [];\n    this._fsl_version            = fsl_version;\n\n    this._graph_layout           = graph_layout;\n\n\n    if (state_declaration) {\n      state_declaration.map( (state_decl: JssmStateDeclaration<mNT>) => {\n\n        if (this._state_declarations.has(state_decl.state)) { // no repeats\n          throw new Error(`Added the same state declaration twice: ${JSON.stringify(state_decl.state)}`);\n        }\n\n        this._state_declarations.set( state_decl.state, transfer_state_properties(state_decl) );\n\n      } );\n    }\n\n\n    transitions.map( (tr:JssmTransition<mNT, mDT>) => {\n\n      if (tr.from === undefined) { throw new Error(`transition must define 'from': ${JSON.stringify(tr)}`); }\n      if (tr.to   === undefined) { throw new Error(`transition must define 'to': ${  JSON.stringify(tr)}`); }\n\n      // get the cursors.  what a mess\n      const cursor_from: JssmGenericState<mNT>\n          = this._states.get(tr.from)\n         || { name: tr.from, from: [], to: [], complete: complete.includes(tr.from) };\n\n      if (!(this._states.has(tr.from))) {\n        this._new_state(cursor_from);\n      }\n\n      const cursor_to: JssmGenericState<mNT>\n          = this._states.get(tr.to)\n         || {name: tr.to, from: [], to: [], complete: complete.includes(tr.to) };\n\n      if (!(this._states.has(tr.to))) {\n        this._new_state(cursor_to);\n      }\n\n      // guard against existing connections being re-added\n      if (cursor_from.to.includes(tr.to)) {\n        throw new Error(`already has ${JSON.stringify(tr.from)} to ${JSON.stringify(tr.to)}`);\n      } else {\n        cursor_from.to.push(tr.to);\n        cursor_to.from.push(tr.from);\n      }\n\n      // add the edge; note its id\n      this._edges.push(tr);\n      const thisEdgeId: number = this._edges.length - 1;\n\n      // guard against repeating a transition name\n      if (tr.name) {\n        if (this._named_transitions.has(tr.name)) {\n          throw new Error(`named transition \"${JSON.stringify(tr.name)}\" already created`);\n        } else {\n          this._named_transitions.set(tr.name, thisEdgeId);\n        }\n      }\n\n      // set up the mapping, so that edges can be looked up by endpoint pairs\n      const from_mapping: Map<mNT, number> = this._edge_map.get(tr.from) || new Map();\n      if (!(this._edge_map.has(tr.from))) {\n        this._edge_map.set(tr.from, from_mapping);\n      }\n\n//    const to_mapping = from_mapping.get(tr.to);\n      from_mapping.set(tr.to, thisEdgeId); // already checked that this mapping doesn't exist, above\n\n      // set up the action mapping, so that actions can be looked up by origin\n      if (tr.action) {\n\n\n        // forward mapping first by action name\n        let actionMap: ?Map<mNT, number> = this._actions.get(tr.action);\n        if (!(actionMap)) {\n          actionMap = new Map();\n          this._actions.set(tr.action, actionMap);\n        }\n\n        if (actionMap.has(tr.from)) {\n          throw new Error(`action ${JSON.stringify(tr.action)} already attached to origin ${JSON.stringify(tr.from)}`);\n        } else {\n          actionMap.set(tr.from, thisEdgeId);\n        }\n\n\n        // reverse mapping first by state origin name\n        let rActionMap: ?Map<mNT, number> = this._reverse_actions.get(tr.from);\n        if (!(rActionMap)) {\n          rActionMap = new Map();\n          this._reverse_actions.set(tr.from, rActionMap);\n        }\n\n        // no need to test for reverse mapping pre-presence;\n        // forward mapping already covers collisions\n        rActionMap.set(tr.action, thisEdgeId);\n\n\n        // reverse mapping first by state target name\n        if (!(this._reverse_action_targets.has(tr.to))) {\n          this._reverse_action_targets.set(tr.to, new Map());\n        }\n\n/* todo comeback\n   fundamental problem is roActionMap needs to be a multimap\n        const roActionMap = this._reverse_action_targets.get(tr.to);  // wasteful - already did has - refactor\n        if (roActionMap) {\n          if (roActionMap.has(tr.action)) {\n            throw new Error(`ro-action ${tr.to} already attached to action ${tr.action}`);\n          } else {\n            roActionMap.set(tr.action, thisEdgeId);\n          }\n        } else {\n          throw new Error('should be impossible - flow doesn\\'t know .set precedes .get yet again.  severe error?');\n        }\n*/\n      }\n\n    });\n\n  }\n\n  _new_state(state_config: JssmGenericState<mNT>): mNT { // whargarbl get that state_config any under control\n\n    if (this._states.has(state_config.name)) {\n      throw new Error(`state ${JSON.stringify(state_config.name)} already exists`);\n    }\n\n    this._states.set(state_config.name, state_config);\n    return state_config.name;\n\n  }\n\n\n\n  state(): mNT {\n    return this._state;\n  }\n\n/* whargarbl todo major\n   when we reimplement this, reintroduce this change to the is_final call\n\n  is_changing(): boolean {\n    return true; // todo whargarbl\n  }\n*/\n\n\n  state_is_final(whichState: mNT): boolean {\n    return ( (this.state_is_terminal(whichState)) && (this.state_is_complete(whichState)) );\n  }\n\n  is_final(): boolean {\n//  return ((!this.is_changing()) && this.state_is_final(this.state()));\n    return this.state_is_final(this.state());\n  }\n\n  graph_layout(): string {\n    return this._graph_layout;\n  }\n\n\n\n  machine_author(): ?Array<string> {\n    return this._machine_author;\n  }\n\n  machine_comment(): ?string {\n    return this._machine_comment;\n  }\n\n  machine_contributor(): ?Array<string> {\n    return this._machine_contributor;\n  }\n\n  machine_definition(): ?string {\n    return this._machine_definition;\n  }\n\n  machine_language(): ?string {\n    return this._machine_language;\n  }\n\n  machine_license(): ?string {\n    return this._machine_license;\n  }\n\n  machine_name(): ?string {\n    return this._machine_name;\n  }\n\n  machine_version(): ?string {\n    return this._machine_version;\n  }\n\n  raw_state_declarations(): ?Array<Object> {    // eslint-disable-line flowtype/no-weak-types\n    return this._raw_state_declaration;\n  }\n\n  state_declaration(which: mNT): ?JssmStateDeclaration<mNT> {\n    return this._state_declarations.get(which);\n  }\n\n  state_declarations(): Map<mNT, Object> {    // eslint-disable-line flowtype/no-weak-types\n    return this._state_declarations;\n  }\n\n  fsl_version(): ?string {\n    return this._fsl_version;\n  }\n\n\n\n  machine_state(): JssmMachineInternalState<mNT, mDT> {\n\n    return {\n      internal_state_impl_version : 1,\n\n      actions                : this._actions,\n      edge_map               : this._edge_map,\n      edges                  : this._edges,\n      named_transitions      : this._named_transitions,\n      reverse_actions        : this._reverse_actions,\n//    reverse_action_targets : this._reverse_action_targets,\n      state                  : this._state,\n      states                 : this._states\n    };\n\n  }\n\n/*\n  load_machine_state(): boolean {\n    return false; // todo whargarbl\n  }\n*/\n\n\n  states(): Array<mNT> {\n    return [... this._states.keys()];\n  }\n\n  state_for(whichState: mNT): JssmGenericState<mNT> {\n    const state: ?JssmGenericState<mNT> = this._states.get(whichState);\n    if (state) { return state; }\n    else       { throw new Error(`no such state ${JSON.stringify(state)}`); }\n  }\n\n\n\n  list_edges(): Array< JssmTransition<mNT, mDT> > {\n    return this._edges;\n  }\n\n  list_named_transitions(): Map<mNT, number> {\n    return this._named_transitions;\n  }\n\n  list_actions(): Array<mNT> {\n    return [... this._actions.keys()];\n  }\n\n\n\n  get_transition_by_state_names(from: mNT, to: mNT): ?number {\n\n    const emg : ?Map<mNT, number> = this._edge_map.get(from);\n\n    if (emg) {\n      return emg.get(to);\n    } else {\n      return undefined;\n    }\n\n  }\n\n\n\n  lookup_transition_for(from: mNT, to: mNT): ?JssmTransition<mNT, mDT> {\n    const id : ?number = this.get_transition_by_state_names(from, to);\n    return ((id === undefined) || (id === null))? undefined : this._edges[id];\n  }\n\n\n\n  list_transitions(whichState: mNT = this.state()): JssmTransitionList<mNT> {\n    return {entrances: this.list_entrances(whichState), exits: this.list_exits(whichState)};\n  }\n\n  list_entrances(whichState: mNT = this.state()): Array<mNT> {\n    return (this._states.get(whichState) || {}).from || [];\n  }\n\n  list_exits(whichState: mNT = this.state()): Array<mNT> {\n    return (this._states.get(whichState) || {}).to   || [];\n  }\n\n\n\n  probable_exits_for(whichState: mNT): Array< JssmTransition<mNT, mDT> > {\n\n    const wstate: ?JssmGenericState<mNT> = this._states.get(whichState);\n    if (!(wstate)) { throw new Error(`No such state ${JSON.stringify(whichState)} in probable_exits_for`); }\n\n    const wstate_to : Array< mNT > = wstate.to,\n\n          wtf       : Array< JssmTransition<mNT, mDT> > // wstate_to_filtered -> wtf\n                    = wstate_to\n                        .map( (ws) : ?JssmTransition<mNT, mDT> => this.lookup_transition_for(this.state(), ws))\n                        .filter(Boolean);\n\n    return wtf;\n\n  }\n\n  probabilistic_transition(): boolean {\n    const selected : JssmTransition<mNT, mDT> = weighted_rand_select(this.probable_exits_for(this.state()));\n    return this.transition( selected.to );\n  }\n\n  probabilistic_walk(n: number): Array<mNT> {\n    return seq(n)\n          .map(() : mNT => {\n             const state_was: mNT = this.state();\n             this.probabilistic_transition();\n             return state_was;\n           })\n          .concat([this.state()]);\n  }\n\n  probabilistic_histo_walk(n: number): Map<mNT, number> {\n    return histograph(this.probabilistic_walk(n));\n  }\n\n\n\n  actions(whichState: mNT = this.state() ): Array<mNT> {\n    const wstate : ?Map<mNT, number> = this._reverse_actions.get(whichState);\n    if (wstate) { return [... wstate.keys()]; }\n    else        { throw new Error(`No such state ${JSON.stringify(whichState)}`); }\n  }\n\n  list_states_having_action(whichState: mNT): Array<mNT> {\n    const wstate : ?Map<mNT, number> = this._actions.get(whichState);\n    if (wstate) { return [... wstate.keys()]; }\n    else        { throw new Error(`No such state ${JSON.stringify(whichState)}`); }\n  }\n\n// comeback\n/*\n  list_entrance_actions(whichState: mNT = this.state() ) : Array<mNT> {\n    return [... (this._reverse_action_targets.get(whichState) || new Map()).values()] // wasteful\n           .map( (edgeId:any) => (this._edges[edgeId] : any)) // whargarbl burn out any\n           .filter( (o:any) => o.to === whichState)\n           .map( filtered => filtered.from );\n  }\n*/\n  list_exit_actions(whichState: mNT = this.state() ): Array<?mNT> { // these are mNT, not ?mNT\n    const ra_base: ?Map<mNT, number> = this._reverse_actions.get(whichState);\n    if (!(ra_base)) { throw new Error(`No such state ${JSON.stringify(whichState)}`); }\n\n    return [... ra_base.values()]\n           .map    ( (edgeId: number)              : JssmTransition<mNT, mDT> => this._edges[edgeId]   )\n           .filter ( (o: JssmTransition<mNT, mDT>) : boolean                  => o.from === whichState )\n           .map    ( (filtered: JssmTransition<mNT, mDT>) : ?mNT              => filtered.action       );\n  }\n\n  probable_action_exits(whichState: mNT = this.state() ) : Array<mixed> { // these are mNT\n    const ra_base: ?Map<mNT, number> = this._reverse_actions.get(whichState);\n    if (!(ra_base)) { throw new Error(`No such state ${JSON.stringify(whichState)}`); }\n\n    return [... ra_base.values()]\n           .map    ( (edgeId: number): JssmTransition<mNT, mDT> => this._edges[edgeId]   )\n           .filter ( (o: JssmTransition<mNT, mDT>): boolean     => o.from === whichState )\n           .map    ( (filtered): mixed                          => ( { action      : filtered.action,\n                                                                       probability : filtered.probability } )\n                                                                   );\n  }\n\n\n\n  is_unenterable(whichState: mNT): boolean {\n    // whargarbl should throw on unknown state\n    return this.list_entrances(whichState).length === 0;\n  }\n\n  has_unenterables(): boolean {\n    return this.states().some( (x): boolean => this.is_unenterable(x));\n  }\n\n\n\n  is_terminal(): boolean {\n    return this.state_is_terminal(this.state());\n  }\n\n  state_is_terminal(whichState: mNT): boolean {\n    // whargarbl should throw on unknown state\n    return this.list_exits(whichState).length === 0;\n  }\n\n  has_terminals(): boolean {\n    return this.states().some( (x): boolean => this.state_is_terminal(x));\n  }\n\n\n\n  is_complete(): boolean {\n    return this.state_is_complete(this.state());\n  }\n\n  state_is_complete(whichState: mNT) : boolean {\n    const wstate: ?JssmGenericState<mNT> = this._states.get(whichState);\n    if (wstate) { return wstate.complete; }\n    else        { throw new Error(`No such state ${JSON.stringify(whichState)}`); }\n  }\n\n  has_completes(): boolean {\n    return this.states().some( (x): boolean => this.state_is_complete(x) );\n  }\n\n\n\n  action(name: mNT, newData?: mDT): boolean {\n    // todo whargarbl implement hooks\n    // todo whargarbl implement data stuff\n    // todo major incomplete whargarbl comeback\n    if (this.valid_action(name, newData)) {\n      const edge: JssmTransition<mNT, mDT> = this.current_action_edge_for(name);\n      this._state = edge.to;\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  transition(newState: mNT, newData?: mDT): boolean {\n    // todo whargarbl implement hooks\n    // todo whargarbl implement data stuff\n    // todo major incomplete whargarbl comeback\n    if (this.valid_transition(newState, newData)) {\n      this._state = newState;\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  // can leave machine in inconsistent state.  generally do not use\n  force_transition(newState: mNT, newData?: mDT): boolean {\n    // todo whargarbl implement hooks\n    // todo whargarbl implement data stuff\n    // todo major incomplete whargarbl comeback\n    if (this.valid_force_transition(newState, newData)) {\n      this._state = newState;\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n\n\n  current_action_for(action: mNT): number | void {\n    const action_base: ?Map<mNT, number> = this._actions.get(action);\n    return action_base? action_base.get(this.state()): undefined;\n  }\n\n  current_action_edge_for(action: mNT): JssmTransition<mNT, mDT> {\n    const idx: ?number = this.current_action_for(action);\n    if ((idx === undefined) || (idx === null)) { throw new Error(`No such action ${JSON.stringify(action)}`); }\n    return this._edges[idx];\n  }\n\n  valid_action(action: mNT, _newData?: mDT): boolean {  // todo comeback unignore newData\n    // todo whargarbl implement hooks\n    // todo whargarbl implement data stuff\n    // todo major incomplete whargarbl comeback\n    return this.current_action_for(action) !== undefined;\n  }\n\n  valid_transition(newState: mNT, _newData?: mDT): boolean {  // todo comeback unignore newData\n    // todo whargarbl implement hooks\n    // todo whargarbl implement data stuff\n    // todo major incomplete whargarbl comeback\n    const transition_for: ?JssmTransition<mNT, mDT> = this.lookup_transition_for(this.state(), newState);\n\n    if (!(transition_for))          { return false; }\n    if (transition_for.forced_only) { return false; }\n\n    return true;\n\n  }\n\n  valid_force_transition(newState: mNT, _newData?: mDT): boolean {  // todo comeback unignore newData\n    // todo whargarbl implement hooks\n    // todo whargarbl implement data stuff\n    // todo major incomplete whargarbl comeback\n    return (this.lookup_transition_for(this.state(), newState) !== undefined);\n  }\n\n\n}\n\n\n\n\n\nfunction sm<mNT, mDT>(template_strings: Array<string> /* , arguments */): Machine<mNT, mDT> {\n\n    // foo`a${1}b${2}c` will come in as (['a','b','c'],1,2)\n    // this includes when a and c are empty strings\n    // therefore template_strings will always have one more el than template_args\n    // therefore map the smaller container and toss the last one on on the way out\n\n    return new Machine(make(template_strings.reduce(\n\n      // in general avoiding `arguments` is smart.  however with the template\n      // string notation, as designed, it's not really worth the hassle\n\n      /* eslint-disable fp/no-arguments */\n      /* eslint-disable prefer-rest-params */\n      (acc, val, idx): string => `${acc}${arguments[idx]}${val}`  // arguments[0] is never loaded, so args doesn't need to be gated\n      /* eslint-enable  prefer-rest-params */\n      /* eslint-enable  fp/no-arguments */\n\n    )));\n\n}\n\n\n\n\n\nexport {\n\n  version,\n\n  transfer_state_properties,\n\n  Machine,\n\n  make,\n    parse,\n    compile,\n\n  sm,\n\n  arrow_direction,\n  arrow_left_kind,\n  arrow_right_kind,\n\n  // todo whargarbl these should be exported to a utility library\n  seq, weighted_rand_select, histograph, weighted_sample_select, weighted_histo_key\n\n};\n"]}