@scion-scxml/core-legacy 1.0.24 → 1.0.26

package/dist/scion.js

@@ -49,198 +49,6 @@
         s(r[o]);
       }return s;
     }({ 1: [function (require, module, exports) {
-        "use strict";
-
-        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;
-          };
-        }();
-
-        function _classCallCheck(instance, Constructor) {
-          if (!(instance instanceof Constructor)) {
-            throw new TypeError("Cannot call a class as a function");
-          }
-        }
-
-        function _possibleConstructorReturn(self, call) {
-          if (!self) {
-            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
-          }return call && ((typeof call === "undefined" ? "undefined" : _typeof2(call)) === "object" || typeof call === "function") ? call : self;
-        }
-
-        function _inherits(subClass, superClass) {
-          if (typeof superClass !== "function" && superClass !== null) {
-            throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof2(superClass)));
-          }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
-        }
-
-        var base = require('@scion-scxml/core-base'),
-            helpers = base.helpers,
-            query = base.query,
-            transitionComparator = base.helpers.transitionComparator;
-
-        /** 
-         * @description Implements SCION legacy semantics. See {@link scion.BaseInterpreter} for information on the constructor arguments.
-         * @class Statechart
-         * @extends BaseInterpreter
-         */
-
-        var Statechart = function (_base$BaseInterpreter) {
-          _inherits(Statechart, _base$BaseInterpreter);
-
-          function Statechart(modelOrModelFactory, opts) {
-            _classCallCheck(this, Statechart);
-
-            opts = opts || {};
-            opts.legacySemantics = true;
-
-            return _possibleConstructorReturn(this, (Statechart.__proto__ || Object.getPrototypeOf(Statechart)).call(this, modelOrModelFactory, opts));
-          }
-
-          /** @private */
-
-          _createClass(Statechart, [{
-            key: "_selectTransitions",
-            value: function _selectTransitions(currentEvent, selectEventlessTransitions) {
-              if (this.opts.onlySelectFromBasicStates) {
-                var states = this._configuration.iter();
-              } else {
-                var statesAndParents = new this.opts.Set();
-
-                //get full configuration, unordered
-                //this means we may select transitions from parents before states
-                var configList = this._configuration.iter();
-                for (var idx = 0, len = configList.length; idx < len; idx++) {
-                  var basicState = configList[idx];
-                  statesAndParents.add(basicState);
-                  var ancestors = query.getAncestors(basicState);
-                  for (var ancIdx = 0, ancLen = ancestors.length; ancIdx < ancLen; ancIdx++) {
-                    statesAndParents.add(ancestors[ancIdx]);
-                  }
-                }
-
-                states = statesAndParents.iter();
-              }
-
-              var transitionSelector = this.opts.transitionSelector;
-              var enabledTransitions = new this.opts.Set();
-
-              var e = this._evaluateAction.bind(this, currentEvent);
-
-              for (var stateIdx = 0, stateLen = states.length; stateIdx < stateLen; stateIdx++) {
-                var transitions = states[stateIdx].transitions;
-                for (var txIdx = 0, len = transitions.length; txIdx < len; txIdx++) {
-                  var t = transitions[txIdx];
-                  if (transitionSelector(t, currentEvent, e, selectEventlessTransitions)) {
-                    enabledTransitions.add(t);
-                  }
-                }
-              }
-
-              var priorityEnabledTransitions = this._selectPriorityEnabledTransitions(enabledTransitions);
-
-              this._log("priorityEnabledTransitions", priorityEnabledTransitions);
-
-              return priorityEnabledTransitions;
-            }
-
-            /** @private */
-
-          }, {
-            key: "_selectPriorityEnabledTransitions",
-            value: function _selectPriorityEnabledTransitions(enabledTransitions) {
-              var priorityEnabledTransitions = new this.opts.Set();
-
-              var tuple = this._getInconsistentTransitions(enabledTransitions),
-                  consistentTransitions = tuple[0],
-                  inconsistentTransitionsPairs = tuple[1];
-
-              priorityEnabledTransitions.union(consistentTransitions);
-
-              this._log("enabledTransitions", enabledTransitions);
-              this._log("consistentTransitions", consistentTransitions);
-              this._log("inconsistentTransitionsPairs", inconsistentTransitionsPairs);
-              this._log("priorityEnabledTransitions", priorityEnabledTransitions);
-
-              while (!inconsistentTransitionsPairs.isEmpty()) {
-                enabledTransitions = new this.opts.Set(inconsistentTransitionsPairs.iter().map(function (t) {
-                  return this.opts.priorityComparisonFn(t);
-                }, this));
-
-                tuple = this._getInconsistentTransitions(enabledTransitions);
-                consistentTransitions = tuple[0];
-                inconsistentTransitionsPairs = tuple[1];
-
-                priorityEnabledTransitions.union(consistentTransitions);
-
-                this._log("enabledTransitions", enabledTransitions);
-                this._log("consistentTransitions", consistentTransitions);
-                this._log("inconsistentTransitionsPairs", inconsistentTransitionsPairs);
-                this._log("priorityEnabledTransitions", priorityEnabledTransitions);
-              }
-              return priorityEnabledTransitions;
-            }
-
-            /** @private */
-
-          }, {
-            key: "_getInconsistentTransitions",
-            value: function _getInconsistentTransitions(transitions) {
-              var allInconsistentTransitions = new this.opts.Set();
-              var inconsistentTransitionsPairs = new this.opts.Set();
-              var transitionList = transitions.iter();
-
-              this._log("transitions", transitions);
-
-              for (var i = 0; i < transitionList.length; i++) {
-                for (var j = i + 1; j < transitionList.length; j++) {
-                  var t1 = transitionList[i];
-                  var t2 = transitionList[j];
-                  if (this._conflicts(t1, t2)) {
-                    allInconsistentTransitions.add(t1);
-                    allInconsistentTransitions.add(t2);
-                    inconsistentTransitionsPairs.add([t1, t2]);
-                  }
-                }
-              }
-
-              var consistentTransitions = transitions.difference(allInconsistentTransitions);
-              return [consistentTransitions, inconsistentTransitionsPairs];
-            }
-          }, {
-            key: "_conflicts",
-            value: function _conflicts(t1, t2) {
-              return !this._isArenaOrthogonal(t1, t2);
-            }
-
-            /** @private */
-
-          }, {
-            key: "_isArenaOrthogonal",
-            value: function _isArenaOrthogonal(t1, t2) {
-
-              this._log("transition scopes", t1.scope, t2.scope);
-
-              var isOrthogonal;
-              isOrthogonal = query.isOrthogonalTo(t1.scope || t1.source, t2.scope || t2.source);
-
-              this._log("transition scopes are orthogonal?", isOrthogonal);
-
-              return isOrthogonal;
-            }
-          }]);
-
-          return Statechart;
-        }(base.BaseInterpreter);
-
-        base.Statechart = Statechart;
-        module.exports = base;
-      }, { "@scion-scxml/core-base": 6 }], 2: [function (require, module, exports) {
         'use strict';
 
         /* begin ArraySet */
@@ -377,7 +185,7 @@
         };
 
         module.exports = ArraySet;
-      }, {}], 3: [function (require, module, exports) {
+      }, {}], 2: [function (require, module, exports) {
         'use strict';
 
         var STATE_TYPES = {
@@ -399,7 +207,7 @@
           HTTP_IOPROCESSOR_TYPE: HTTP_IOPROCESSOR_TYPE,
           RX_TRAILING_WILDCARD: RX_TRAILING_WILDCARD
         };
-      }, {}], 4: [function (require, module, exports) {
+      }, {}], 3: [function (require, module, exports) {
         'use strict';
 
         var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
@@ -480,7 +288,8 @@
                 transitions: [{
                   target: state
                 }]
-              }, state]
+              }, state],
+              modelFnName: state.modelFnName
             };
           }
 
@@ -835,7 +644,9 @@
         }
 
         function initializeModelGeneratorFn(modelFn, opts, interpreter) {
-          return modelFn.call(interpreter, opts._x, opts._x._sessionid, opts._x._ioprocessors, interpreter.isIn.bind(interpreter));
+          var model = modelFn.call(interpreter, opts._x, opts._x._sessionid, opts._x._ioprocessors, interpreter.isIn.bind(interpreter));
+          model.modelFnName = modelFn.name;
+          return model;
         }
 
         function deserializeSerializedConfiguration(serializedConfiguration, idToStateMap) {
@@ -857,7 +668,7 @@
           });
           return o;
         }
-      }, { "./constants": 3 }], 5: [function (require, module, exports) {
+      }, { "./constants": 2 }], 4: [function (require, module, exports) {
         'use strict';
 
         var constants = require('./constants');
@@ -901,7 +712,7 @@
         };
 
         module.exports = query;
-      }, { "./constants": 3 }], 6: [function (require, module, exports) {
+      }, { "./constants": 2 }], 5: [function (require, module, exports) {
         (function (process) {
           //   Copyright 2012-2012 Jacob Beard, INFICON, and other SCION contributors
           //
@@ -1123,6 +934,7 @@
               _this._isStepping = false;
 
               _this._scriptingContext = _this.opts.interpreterScriptingContext || (_this.opts.InterpreterScriptingContext ? new _this.opts.InterpreterScriptingContext(_this) : {});
+              _this._scriptingContext._invokeMap = _this.opts._invokeMap || _this._scriptingContext._invokeMap;
 
               _this.opts.generateSessionid = _this.opts.generateSessionid || BaseInterpreter.generateSessionid;
               _this.opts.sessionid = _this.opts.sessionid || _this.opts.generateSessionid();
@@ -1206,7 +1018,11 @@
             _createClass(BaseInterpreter, [{
               key: 'cancel',
               value: function cancel() {
-                delete this.opts.parentSession;
+                var _this2 = this;
+
+                setImmediate(function () {
+                  return delete _this2.opts.parentSession;
+                }); // run this asynchronously, as we still need a reference to the parent session to send the final <done> event
                 if (this._isInFinalState) return;
                 this._isInFinalState = true;
                 this._log('session cancelled ' + this.opts.invokeid);
@@ -1215,7 +1031,7 @@
             }, {
               key: '_exitInterpreter',
               value: function _exitInterpreter(event) {
-                var _this2 = this;
+                var _this3 = this;
 
                 //TODO: cancel invoked sessions
                 //cancel all delayed sends when we enter into a final state.
@@ -1243,7 +1059,7 @@
 
                   //cancel invoked session
                   if (stateExited.invokes) stateExited.invokes.forEach(function (invoke) {
-                    _this2._scriptingContext.cancelInvoke(invoke.id);
+                    _this3._scriptingContext.cancelInvoke(invoke.id);
                   });
 
                   //if he is a top-level <final> state, then return the done event
@@ -1327,7 +1143,7 @@
             }, {
               key: '_initStart',
               value: function _initStart(cb) {
-                var _this3 = this;
+                var _this4 = this;
 
                 if (typeof cb !== 'function') {
                   cb = nop;
@@ -1339,7 +1155,7 @@
                 //but if we want it to be parallel, then this becomes more complex. so when initializing the model, we add a 'fake' root state, which
                 //makes the following operation safe.
                 this._model.initialRef.forEach(function (s) {
-                  return _this3._configuration.add(s);
+                  return _this4._configuration.add(s);
                 });
 
                 return cb;
@@ -1477,7 +1293,7 @@
             }, {
               key: '_startBigStep',
               value: function _startBigStep(e) {
-                var _this4 = this;
+                var _this5 = this;
 
                 this.emit('onBigStepBegin', e);
 
@@ -1486,7 +1302,7 @@
                   if (state.invokes) state.invokes.forEach(function (invoke) {
                     if (invoke.autoforward) {
                       //autoforward
-                      _this4._scriptingContext.send({
+                      _this5._scriptingContext.send({
                         target: '#_' + invoke.id,
                         name: e.name,
                         data: e.data
@@ -1495,7 +1311,7 @@
                     if (invoke.id === e.invokeid) {
                       //applyFinalize
                       if (invoke.finalize) invoke.finalize.forEach(function (action) {
-                        return _this4._evaluateAction(e, action);
+                        return _this5._evaluateAction(e, action);
                       });
                     }
                   });
@@ -1512,23 +1328,23 @@
             }, {
               key: '_finishBigStep',
               value: function _finishBigStep(e, allStatesEntered, allStatesExited, cb) {
-                var _this5 = this;
+                var _this6 = this;
 
-                var statesToInvoke = Array.from(new Set([].concat(_toConsumableArray(allStatesEntered)).filter(function (s) {
-                  return s.invokes && !allStatesExited.has(s);
-                }))).sort(sortInEntryOrder);
+                var statesToInvoke = Array.from(allStatesEntered).filter(function (s) {
+                  return s.invokes;
+                }).sort(sortInEntryOrder);
 
                 // Here we invoke whatever needs to be invoked. The implementation of 'invoke' is platform-specific
                 statesToInvoke.forEach(function (s) {
                   s.invokes.forEach(function (f) {
-                    return _this5._evaluateAction(e, f);
+                    return _this6._evaluateAction(e, f);
                   });
                 });
 
                 // cancel invoke for allStatesExited
                 allStatesExited.forEach(function (s) {
                   if (s.invokes) s.invokes.forEach(function (invoke) {
-                    _this5._scriptingContext.cancelInvoke(invoke.id);
+                    _this6._scriptingContext.cancelInvoke(invoke.id);
                   });
                 });
 
@@ -1795,7 +1611,7 @@
             }, {
               key: '_enterStates',
               value: function _enterStates(currentEvent, selectedTransitionsWithTargets) {
-                var _this6 = this;
+                var _this7 = this;
 
                 this._log("entering states");
 
@@ -1899,7 +1715,7 @@
                     this._internalEventQueue.push({ name: "done.state." + parent.id, data: stateEntered.donedata && stateEntered.donedata.call(this._scriptingContext, currentEvent) });
                     if (grandparent && grandparent.typeEnum === PARALLEL) {
                       if (grandparent.states.every(function (s) {
-                        return _this6.isInFinalState(s);
+                        return _this7.isInFinalState(s);
                       })) {
                         this._internalEventQueue.push({ name: "done.state." + grandparent.id });
                       }
@@ -2084,7 +1900,7 @@
             }, {
               key: '_addAncestorStatesToEnter',
               value: function _addAncestorStatesToEnter(state, ancestor, statesToEnter, statesForDefaultEntry, defaultHistoryContent) {
-                var _this7 = this;
+                var _this8 = this;
 
                 var traverse = function traverse(anc) {
                   if (anc.typeEnum === PARALLEL) {
@@ -2099,7 +1915,7 @@
                         if (child.typeEnum !== HISTORY && ![].concat(_toConsumableArray(statesToEnter)).some(function (s) {
                           return query.isDescendant(s, child);
                         })) {
-                          _this7._addDescendantStatesToEnter(child, statesToEnter, statesForDefaultEntry, defaultHistoryContent);
+                          _this8._addDescendantStatesToEnter(child, statesToEnter, statesForDefaultEntry, defaultHistoryContent);
                         }
                       };
 
@@ -2153,7 +1969,7 @@
             }, {
               key: '_addDescendantStatesToEnter',
               value: function _addDescendantStatesToEnter(state, statesToEnter, statesForDefaultEntry, defaultHistoryContent) {
-                var _this8 = this;
+                var _this9 = this;
 
                 if (state.typeEnum === HISTORY) {
                   if (this._historyValue[state.id]) {
@@ -2373,7 +2189,7 @@
                           if (child.typeEnum !== HISTORY && ![].concat(_toConsumableArray(statesToEnter)).some(function (s) {
                             return query.isDescendant(s, child);
                           })) {
-                            _this8._addDescendantStatesToEnter(child, statesToEnter, statesForDefaultEntry, defaultHistoryContent);
+                            _this9._addDescendantStatesToEnter(child, statesToEnter, statesForDefaultEntry, defaultHistoryContent);
                           }
                         };
 
@@ -2401,11 +2217,11 @@
             }, {
               key: 'isInFinalState',
               value: function isInFinalState(s) {
-                var _this9 = this;
+                var _this10 = this;
 
                 if (s.typeEnum === COMPOSITE) {
                   return s.states.some(function (s) {
-                    return s.typeEnum === FINAL && _this9._configuration.contains(s);
+                    return s.typeEnum === FINAL && _this10._configuration.contains(s);
                   });
                 } else if (s.typeEnum === PARALLEL) {
                   return s.states.every(this.isInFinalState.bind(this));
@@ -2783,14 +2599,14 @@
             }, {
               key: 'invoke',
               value: function invoke(invokeObj) {
-                var _this10 = this;
+                var _this11 = this;
 
                 //look up invoker by type. assume invokers are passed in as an option to constructor
                 this._invokeMap[invokeObj.id] = new Promise(function (resolve, reject) {
-                  (_this10._interpreter.opts.invokers || InterpreterScriptingContext.invokers)[invokeObj.type](_this10._interpreter, invokeObj, _this10._interpreter.opts.invokerExecutionContext, function (err, session) {
+                  (_this11._interpreter.opts.invokers || InterpreterScriptingContext.invokers)[invokeObj.type](_this11._interpreter, invokeObj, _this11._interpreter.opts.invokerExecutionContext, function (err, session) {
                     if (err) return reject(err);
 
-                    _this10._interpreter.emit('onInvokedSessionInitialized', session);
+                    _this11._interpreter.emit('onInvokedSessionInitialized', session);
                     resolve(session);
                   });
                 });
@@ -2798,7 +2614,7 @@
             }, {
               key: 'cancelInvoke',
               value: function cancelInvoke(invokeid) {
-                var _this11 = this;
+                var _this12 = this;
 
                 //TODO: on cancel invoke clean up this._invokeMap
                 var sessionPromise = this._invokeMap[invokeid];
@@ -2806,10 +2622,10 @@
                 if (sessionPromise) {
                   this._interpreter._log('sessionPromise found');
                   sessionPromise.then(function (session) {
-                    _this11._interpreter._log('resolved session ' + invokeid + '. cancelling... ');
+                    _this12._interpreter._log('resolved session ' + invokeid + '. cancelling... ');
                     session.cancel();
                     //clean up
-                    delete _this11._invokeMap[invokeid];
+                    delete _this12._invokeMap[invokeid];
                   }, function (err) {
                     //TODO: dispatch error back into the state machine as error.communication
                   });
@@ -2854,7 +2670,7 @@
                 }
 
                 function defaultSendAction(event, options) {
-                  var _this12 = this;
+                  var _this13 = this;
 
                   if (typeof setTimeout === 'undefined') throw new Error('Default implementation of BaseInterpreter.prototype.send will not work unless setTimeout is defined globally.');
 
@@ -2886,7 +2702,7 @@
                       //TODO: test this code path.
                       var invokeId = match[1];
                       this._invokeMap[invokeId].then(function (session) {
-                        doSend.call(_this12, session);
+                        doSend.call(_this13, session);
                       });
                     } else {
                       throw new Error('Unrecognized send target.'); //TODO: dispatch error back into the state machine
@@ -2900,8 +2716,9 @@
                     var timeoutHandle = setTimeout(function () {
                       if (event.sendid) delete this._timeoutMap[event.sendid];
                       this._timeouts.delete(timeoutOptions);
-                      if (this._interpreter.opts.doSend) {
-                        this._interpreter.opts.doSend(session, event);
+                      var _doSend = this._interpreter.opts.doSend || BaseInterpreter.doSend;
+                      if (_doSend) {
+                        _doSend(session, event);
                       } else {
                         session[this._interpreter.opts.sendAsync ? 'genAsync' : 'gen'](event);
                       }
@@ -2966,34 +2783,302 @@
             query: query
           });
         }).call(this, require('_process'));
-      }, { "./ArraySet": 2, "./constants": 3, "./helpers": 4, "./query": 5, "_process": 7, "tiny-events": 8, "util": 11 }], 7: [function (require, module, exports) {
-        // shim for using process in browser
-        var process = module.exports = {};
+      }, { "./ArraySet": 1, "./constants": 2, "./helpers": 3, "./query": 4, "_process": 8, "tiny-events": 6, "util": 11 }], 6: [function (require, module, exports) {
+        function EventEmitter() {
+          this._listeners = {};
+        }
 
-        // cached from whatever global is present so that test runners that stub it
-        // don't break things.  But we need to wrap it in a try catch in case it is
-        // wrapped in strict mode code which doesn't define any globals.  It's inside a
-        // function because try/catches deoptimize in certain engines.
+        EventEmitter.prototype.on = function _on(type, listener) {
+          if (!Array.isArray(this._listeners[type])) {
+            this._listeners[type] = [];
+          }
 
-        var cachedSetTimeout;
-        var cachedClearTimeout;
+          if (this._listeners[type].indexOf(listener) === -1) {
+            this._listeners[type].push(listener);
+          }
 
-        function defaultSetTimout() {
-          throw new Error('setTimeout has not been defined');
-        }
-        function defaultClearTimeout() {
-          throw new Error('clearTimeout has not been defined');
-        }
-        (function () {
-          try {
-            if (typeof setTimeout === 'function') {
-              cachedSetTimeout = setTimeout;
-            } else {
-              cachedSetTimeout = defaultSetTimout;
+          return this;
+        };
+
+        EventEmitter.prototype.once = function _once(type, listener) {
+          var self = this;
+
+          function __once() {
+            for (var args = [], i = 0; i < arguments.length; i += 1) {
+              args[i] = arguments[i];
             }
-          } catch (e) {
-            cachedSetTimeout = defaultSetTimout;
-          }
+
+            self.off(type, __once);
+            listener.apply(self, args);
+          }
+
+          __once.listener = listener;
+
+          return this.on(type, __once);
+        };
+
+        EventEmitter.prototype.off = function _off(type, listener) {
+          if (!Array.isArray(this._listeners[type])) {
+            return this;
+          }
+
+          if (typeof listener === 'undefined') {
+            this._listeners[type] = [];
+            return this;
+          }
+
+          var index = this._listeners[type].indexOf(listener);
+
+          if (index === -1) {
+            for (var i = 0; i < this._listeners[type].length; i += 1) {
+              if (this._listeners[type][i].listener === listener) {
+                index = i;
+                break;
+              }
+            }
+          }
+
+          this._listeners[type].splice(index, 1);
+          return this;
+        };
+
+        EventEmitter.prototype.emit = function _emit(type) {
+          if (!Array.isArray(this._listeners[type])) {
+            return this;
+          }
+
+          for (var args = [], i = 1; i < arguments.length; i += 1) {
+            args[i - 1] = arguments[i];
+          }
+
+          this._listeners[type].forEach(function __emit(listener) {
+            listener.apply(this, args);
+          }, this);
+
+          return this;
+        };
+
+        module.exports.EventEmitter = EventEmitter;
+      }, {}], 7: [function (require, module, exports) {
+        "use strict";
+
+        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;
+          };
+        }();
+
+        function _classCallCheck(instance, Constructor) {
+          if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+
+        function _possibleConstructorReturn(self, call) {
+          if (!self) {
+            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+          }return call && ((typeof call === "undefined" ? "undefined" : _typeof2(call)) === "object" || typeof call === "function") ? call : self;
+        }
+
+        function _inherits(subClass, superClass) {
+          if (typeof superClass !== "function" && superClass !== null) {
+            throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === "undefined" ? "undefined" : _typeof2(superClass)));
+          }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+        }
+
+        var base = require('@scion-scxml/core-base'),
+            helpers = base.helpers,
+            query = base.query,
+            transitionComparator = base.helpers.transitionComparator;
+
+        /** 
+         * @description Implements SCION legacy semantics. See {@link scion.BaseInterpreter} for information on the constructor arguments.
+         * @class Statechart
+         * @extends BaseInterpreter
+         */
+
+        var Statechart = function (_base$BaseInterpreter) {
+          _inherits(Statechart, _base$BaseInterpreter);
+
+          function Statechart(modelOrModelFactory, opts) {
+            _classCallCheck(this, Statechart);
+
+            opts = opts || {};
+            opts.legacySemantics = true;
+
+            return _possibleConstructorReturn(this, (Statechart.__proto__ || Object.getPrototypeOf(Statechart)).call(this, modelOrModelFactory, opts));
+          }
+
+          /** @private */
+
+          _createClass(Statechart, [{
+            key: "_selectTransitions",
+            value: function _selectTransitions(currentEvent, selectEventlessTransitions) {
+              if (this.opts.onlySelectFromBasicStates) {
+                var states = this._configuration.iter();
+              } else {
+                var statesAndParents = new this.opts.Set();
+
+                //get full configuration, unordered
+                //this means we may select transitions from parents before states
+                var configList = this._configuration.iter();
+                for (var idx = 0, len = configList.length; idx < len; idx++) {
+                  var basicState = configList[idx];
+                  statesAndParents.add(basicState);
+                  var ancestors = query.getAncestors(basicState);
+                  for (var ancIdx = 0, ancLen = ancestors.length; ancIdx < ancLen; ancIdx++) {
+                    statesAndParents.add(ancestors[ancIdx]);
+                  }
+                }
+
+                states = statesAndParents.iter();
+              }
+
+              var transitionSelector = this.opts.transitionSelector;
+              var enabledTransitions = new this.opts.Set();
+
+              var e = this._evaluateAction.bind(this, currentEvent);
+
+              for (var stateIdx = 0, stateLen = states.length; stateIdx < stateLen; stateIdx++) {
+                var transitions = states[stateIdx].transitions;
+                for (var txIdx = 0, len = transitions.length; txIdx < len; txIdx++) {
+                  var t = transitions[txIdx];
+                  if (transitionSelector(t, currentEvent, e, selectEventlessTransitions)) {
+                    enabledTransitions.add(t);
+                  }
+                }
+              }
+
+              var priorityEnabledTransitions = this._selectPriorityEnabledTransitions(enabledTransitions);
+
+              this._log("priorityEnabledTransitions", priorityEnabledTransitions);
+
+              return priorityEnabledTransitions;
+            }
+
+            /** @private */
+
+          }, {
+            key: "_selectPriorityEnabledTransitions",
+            value: function _selectPriorityEnabledTransitions(enabledTransitions) {
+              var priorityEnabledTransitions = new this.opts.Set();
+
+              var tuple = this._getInconsistentTransitions(enabledTransitions),
+                  consistentTransitions = tuple[0],
+                  inconsistentTransitionsPairs = tuple[1];
+
+              priorityEnabledTransitions.union(consistentTransitions);
+
+              this._log("enabledTransitions", enabledTransitions);
+              this._log("consistentTransitions", consistentTransitions);
+              this._log("inconsistentTransitionsPairs", inconsistentTransitionsPairs);
+              this._log("priorityEnabledTransitions", priorityEnabledTransitions);
+
+              while (!inconsistentTransitionsPairs.isEmpty()) {
+                enabledTransitions = new this.opts.Set(inconsistentTransitionsPairs.iter().map(function (t) {
+                  return this.opts.priorityComparisonFn(t);
+                }, this));
+
+                tuple = this._getInconsistentTransitions(enabledTransitions);
+                consistentTransitions = tuple[0];
+                inconsistentTransitionsPairs = tuple[1];
+
+                priorityEnabledTransitions.union(consistentTransitions);
+
+                this._log("enabledTransitions", enabledTransitions);
+                this._log("consistentTransitions", consistentTransitions);
+                this._log("inconsistentTransitionsPairs", inconsistentTransitionsPairs);
+                this._log("priorityEnabledTransitions", priorityEnabledTransitions);
+              }
+              return priorityEnabledTransitions;
+            }
+
+            /** @private */
+
+          }, {
+            key: "_getInconsistentTransitions",
+            value: function _getInconsistentTransitions(transitions) {
+              var allInconsistentTransitions = new this.opts.Set();
+              var inconsistentTransitionsPairs = new this.opts.Set();
+              var transitionList = transitions.iter();
+
+              this._log("transitions", transitions);
+
+              for (var i = 0; i < transitionList.length; i++) {
+                for (var j = i + 1; j < transitionList.length; j++) {
+                  var t1 = transitionList[i];
+                  var t2 = transitionList[j];
+                  if (this._conflicts(t1, t2)) {
+                    allInconsistentTransitions.add(t1);
+                    allInconsistentTransitions.add(t2);
+                    inconsistentTransitionsPairs.add([t1, t2]);
+                  }
+                }
+              }
+
+              var consistentTransitions = transitions.difference(allInconsistentTransitions);
+              return [consistentTransitions, inconsistentTransitionsPairs];
+            }
+          }, {
+            key: "_conflicts",
+            value: function _conflicts(t1, t2) {
+              return !this._isArenaOrthogonal(t1, t2);
+            }
+
+            /** @private */
+
+          }, {
+            key: "_isArenaOrthogonal",
+            value: function _isArenaOrthogonal(t1, t2) {
+
+              this._log("transition scopes", t1.scope, t2.scope);
+
+              var isOrthogonal;
+              isOrthogonal = query.isOrthogonalTo(t1.scope || t1.source, t2.scope || t2.source);
+
+              this._log("transition scopes are orthogonal?", isOrthogonal);
+
+              return isOrthogonal;
+            }
+          }]);
+
+          return Statechart;
+        }(base.BaseInterpreter);
+
+        base.Statechart = Statechart;
+        module.exports = base;
+      }, { "@scion-scxml/core-base": 5 }], 8: [function (require, module, exports) {
+        // shim for using process in browser
+        var process = module.exports = {};
+
+        // cached from whatever global is present so that test runners that stub it
+        // don't break things.  But we need to wrap it in a try catch in case it is
+        // wrapped in strict mode code which doesn't define any globals.  It's inside a
+        // function because try/catches deoptimize in certain engines.
+
+        var cachedSetTimeout;
+        var cachedClearTimeout;
+
+        function defaultSetTimout() {
+          throw new Error('setTimeout has not been defined');
+        }
+        function defaultClearTimeout() {
+          throw new Error('clearTimeout has not been defined');
+        }
+        (function () {
+          try {
+            if (typeof setTimeout === 'function') {
+              cachedSetTimeout = setTimeout;
+            } else {
+              cachedSetTimeout = defaultSetTimout;
+            }
+          } catch (e) {
+            cachedSetTimeout = defaultSetTimout;
+          }
           try {
             if (typeof clearTimeout === 'function') {
               cachedClearTimeout = clearTimeout;
@@ -3152,82 +3237,6 @@
         process.umask = function () {
           return 0;
         };
-      }, {}], 8: [function (require, module, exports) {
-        function EventEmitter() {
-          this._listeners = {};
-        }
-
-        EventEmitter.prototype.on = function _on(type, listener) {
-          if (!Array.isArray(this._listeners[type])) {
-            this._listeners[type] = [];
-          }
-
-          if (this._listeners[type].indexOf(listener) === -1) {
-            this._listeners[type].push(listener);
-          }
-
-          return this;
-        };
-
-        EventEmitter.prototype.once = function _once(type, listener) {
-          var self = this;
-
-          function __once() {
-            for (var args = [], i = 0; i < arguments.length; i += 1) {
-              args[i] = arguments[i];
-            }
-
-            self.off(type, __once);
-            listener.apply(self, args);
-          }
-
-          __once.listener = listener;
-
-          return this.on(type, __once);
-        };
-
-        EventEmitter.prototype.off = function _off(type, listener) {
-          if (!Array.isArray(this._listeners[type])) {
-            return this;
-          }
-
-          if (typeof listener === 'undefined') {
-            this._listeners[type] = [];
-            return this;
-          }
-
-          var index = this._listeners[type].indexOf(listener);
-
-          if (index === -1) {
-            for (var i = 0; i < this._listeners[type].length; i += 1) {
-              if (this._listeners[type][i].listener === listener) {
-                index = i;
-                break;
-              }
-            }
-          }
-
-          this._listeners[type].splice(index, 1);
-          return this;
-        };
-
-        EventEmitter.prototype.emit = function _emit(type) {
-          if (!Array.isArray(this._listeners[type])) {
-            return this;
-          }
-
-          for (var args = [], i = 1; i < arguments.length; i += 1) {
-            args[i - 1] = arguments[i];
-          }
-
-          this._listeners[type].forEach(function __emit(listener) {
-            listener.apply(this, args);
-          }, this);
-
-          return this;
-        };
-
-        module.exports.EventEmitter = EventEmitter;
       }, {}], 9: [function (require, module, exports) {
         if (typeof Object.create === 'function') {
           // implementation from standard node.js 'util' module
@@ -3803,7 +3812,7 @@
             return Object.prototype.hasOwnProperty.call(obj, prop);
           }
         }).call(this, require('_process'), typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {});
-      }, { "./support/isBuffer": 10, "_process": 7, "inherits": 9 }] }, {}, [1])(1);
+      }, { "./support/isBuffer": 10, "_process": 8, "inherits": 9 }] }, {}, [7])(7);
   });
 });
 //# sourceMappingURL=scion.js.map