1
|
function _sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
|
2
|
|
3
|
function _slicedToArray(arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return _sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }
|
4
|
|
5
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
6
|
|
7
|
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); } }
|
8
|
|
9
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
|
10
|
|
11
|
var STOP = Symbol("STOP");
|
12
|
|
13
|
function makeTransition(regex, nextState) {
|
14
|
var _ref = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
|
15
|
_ref$n = _ref.n,
|
16
|
n = _ref$n === void 0 ? 1 : _ref$n,
|
17
|
allowedSeparator = _ref.allowedSeparator;
|
18
|
|
19
|
return function (instance) {
|
20
|
if (allowedSeparator) {
|
21
|
if (instance.input[instance.ptr] === allowedSeparator) {
|
22
|
if (regex.test(instance.input.substring(instance.ptr - 1, instance.ptr))) {
|
23
|
// Consume the separator and stay in current state
|
24
|
return [instance.currentState, 1];
|
25
|
} else {
|
26
|
return [instance.terminatingState, 0];
|
27
|
}
|
28
|
}
|
29
|
}
|
30
|
|
31
|
if (regex.test(instance.input.substring(instance.ptr, instance.ptr + n))) {
|
32
|
return [nextState, n];
|
33
|
}
|
34
|
|
35
|
return false;
|
36
|
};
|
37
|
}
|
38
|
|
39
|
function combineTransitions(transitions) {
|
40
|
return function () {
|
41
|
var match = false;
|
42
|
var currentTransitions = transitions[this.currentState] || [];
|
43
|
|
44
|
for (var i = 0; i < currentTransitions.length; ++i) {
|
45
|
match = currentTransitions[i](this);
|
46
|
|
47
|
if (match !== false) {
|
48
|
break;
|
49
|
}
|
50
|
}
|
51
|
|
52
|
return match || [this.terminatingState, 0];
|
53
|
};
|
54
|
}
|
55
|
|
56
|
var FSM =
|
57
|
/*#__PURE__*/
|
58
|
function () {
|
59
|
function FSM(transitions, initialState) {
|
60
|
var terminatingState = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : STOP;
|
61
|
|
62
|
_classCallCheck(this, FSM);
|
63
|
|
64
|
this.initialState = initialState;
|
65
|
this.terminatingState = terminatingState;
|
66
|
|
67
|
if (terminatingState === STOP || !transitions[terminatingState]) {
|
68
|
transitions[terminatingState] = [];
|
69
|
}
|
70
|
|
71
|
this.transitionFunction = combineTransitions.call(this, transitions);
|
72
|
}
|
73
|
|
74
|
_createClass(FSM, [{
|
75
|
key: "run",
|
76
|
value: function run(input) {
|
77
|
this.input = input;
|
78
|
this.ptr = 0;
|
79
|
this.currentState = this.initialState;
|
80
|
var value = "";
|
81
|
var eatLength, nextState;
|
82
|
|
83
|
while (this.currentState !== this.terminatingState && this.ptr < this.input.length) {
|
84
|
var _transitionFunction = this.transitionFunction();
|
85
|
|
86
|
var _transitionFunction2 = _slicedToArray(_transitionFunction, 2);
|
87
|
|
88
|
nextState = _transitionFunction2[0];
|
89
|
eatLength = _transitionFunction2[1];
|
90
|
value += this.input.substring(this.ptr, this.ptr += eatLength);
|
91
|
this.currentState = nextState;
|
92
|
}
|
93
|
|
94
|
return value;
|
95
|
}
|
96
|
}]);
|
97
|
|
98
|
return FSM;
|
99
|
}();
|
100
|
|
101
|
export { makeTransition, FSM };
|