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.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 parse = require('./jssm-dot.js').parse; // eslint-disable-line flowtype/no-weak-types // todo whargarbl remove any

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


function arrow_direction(arrow) {

  switch (String(arrow)) {

    case '->':case '=>':case '~>':
      return 'right';

    case '<-':case '<=':case '<~':
      return 'left';

    case '<->':case '<-=>':case '<-~>':
    case '<=>':case '<=->':case '<=~>':
    case '<~>':case '<~->':case '<~=>':
      return 'both';

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

  }
}

function arrow_left_kind(arrow) {

  switch (String(arrow)) {

    case '->':case '=>':case '~>':
      return 'none';

    case '<-':case '<->':case '<-=>':case '<-~>':
      return 'legal';

    case '<=':case '<=>':case '<=->':case '<=~>':
      return 'main';

    case '<~':case '<~>':case '<~->':case '<~=>':
      return 'forced';

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

  }
}

function arrow_right_kind(arrow) {

  switch (String(arrow)) {

    case '<-':case '<=':case '<~':
      return 'none';

    case '->':case '<->':case '<=->':case '<~->':
      return 'legal';

    case '=>':case '<=>':case '<-=>':case '<~=>':
      return 'main';

    case '~>':case '<~>':case '<-~>':case '<=~>':
      return 'forced';

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

  }
}

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) };
  }

  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: [],
    machine_name: [],
    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);
  });

  ['graph_layout', 'machine_name', 'machine_version'].map(function (oneOnlyKey) {
    if (results[oneOnlyKey].length > 1) {
      throw new Error('May only have one ' + oneOnlyKey + ' statement maximum: ' + JSON.stringify(results[oneOnlyKey]));
    }
  });

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

  var result_cfg = {
    // whargarbl should be    initial_state : results.initial_state[0],
    start_states: results.start_states.length ? results.start_states : [assembled_transitions[0].from],
    transitions: assembled_transitions
  };

  if (results.graph_layout.length) {
    result_cfg.layout = results.graph_layout[0];
  }

  return result_cfg;
}

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

var Machine = function () {

  // whargarbl this badly needs to be broken up, monolith master
  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,
        _ref2$layout = _ref2.layout,
        layout = _ref2$layout === undefined ? 'dot' : _ref2$layout;

    _classCallCheck(this, Machine);

    this._state = start_states[0];
    this._states = 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._layout = layout;

    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: 'layout',
    value: function layout() {
      return String(this._layout);
    }
  }, {
    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.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.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":["parse","require","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","tautologies","includes","value","JSON","stringify","compile","tree","results","graph_layout","transition","start_states","end_states","machine_name","machine_version","tr","oneOnlyKey","length","assembled_transitions","result_cfg","transitions","layout","make","plan","Machine","complete","_state","_states","Map","_edges","_edge_map","_named_transitions","_actions","_reverse_actions","_reverse_action_targets","_layout","undefined","cursor_from","get","name","has","_new_state","cursor_to","thisEdgeId","set","from_mapping","actionMap","rActionMap","state_config","whichState","state_is_terminal","state_is_complete","state_is_final","state","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","reduce","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\nimport type {\n\n  JssmGenericState, JssmGenericConfig,\n  JssmTransition, JssmTransitionList,\n  JssmMachineInternalState,\n  JssmParseTree,\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\nfunction arrow_direction(arrow : JssmArrow) : JssmArrowDirection {\n\n  switch ( String(arrow) ) {\n\n    case '->' :  case '=>'  :  case '~>'  :\n      return 'right';\n\n    case '<-' :  case '<='  :  case '<~'  :\n      return 'left';\n\n    case '<->':  case '<-=>':  case '<-~>':\n    case '<=>':  case '<=->':  case '<=~>':\n    case '<~>':  case '<~->':  case '<~=>':\n      return 'both';\n\n    default:\n      throw new Error(`arrow_direction: unknown arrow type ${arrow}`);\n\n  }\n\n}\n\n\n\n\n\nfunction arrow_left_kind(arrow : JssmArrow) : JssmArrowKind {\n\n  switch ( String(arrow) ) {\n\n    case '->':  case '=>' :  case '~>':\n      return 'none';\n\n    case '<-':  case '<->':  case '<-=>':  case '<-~>':\n      return 'legal';\n\n    case '<=':  case '<=>':  case '<=->':  case '<=~>':\n      return 'main';\n\n    case '<~':  case '<~>':  case '<~->':  case '<~=>':\n      return 'forced';\n\n    default:\n      throw new Error(`arrow_direction: unknown arrow type ${arrow}`);\n\n  }\n\n}\n\n\n\n\n\nfunction arrow_right_kind(arrow : JssmArrow) : JssmArrowKind {\n\n  switch ( String(arrow) ) {\n\n    case '<-':  case '<=' :  case '<~':\n      return 'none';\n\n    case '->':  case '<->':  case '<=->':  case '<~->':\n      return 'legal';\n\n    case '=>':  case '<=>':  case '<-=>':  case '<~=>':\n      return 'main';\n\n    case '~>':  case '<~>':  case '<-~>':  case '<=~>':\n      return 'forced';\n\n    default:\n      throw new Error(`arrow_direction: unknown arrow type ${arrow}`);\n\n  }\n\n}\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') { return { agg_as: 'transition', val: compile_rule_handle_transition(rule) }; }\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\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    machine_name    : Array< string >,\n    machine_version : Array< string > // semver\n  } = {\n    graph_layout    : [],\n    transition      : [],\n    start_states    : [],\n    end_states      : [],\n    machine_name    : [],\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  ['graph_layout', 'machine_name', 'machine_version'].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    }\n  });\n\n  const assembled_transitions : Array< JssmTransition<mNT, mDT> > = [].concat(... results['transition']);\n\n  const result_cfg : JssmGenericConfig<mNT, mDT> = {\n// whargarbl should be    initial_state : results.initial_state[0],\n    start_states : results.start_states.length? results.start_states : [assembled_transitions[0].from],\n    transitions  : assembled_transitions\n  };\n\n  if (results.graph_layout.length) { result_cfg.layout = results.graph_layout[0]; }\n\n  return result_cfg;\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\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  _layout                 : JssmLayout;\n\n  // whargarbl this badly needs to be broken up, monolith master\n  constructor({ start_states, complete=[], transitions, layout = 'dot' } : JssmGenericConfig<mNT, mDT>) {\n\n    this._state                  = start_states[0];\n    this._states                 = 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._layout                 = layout;\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  layout() : string {\n    return String(this._layout);\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> >\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  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"]}