fas-js 1.4.0 → 1.6.0

package/lib/index.js

@@ -92,24 +92,24 @@ var DFAUtils = class {
    * Transition function should only contain states in Q, and one transition should exist
    * for each combination of Q x Σ
    */
-  static validateTFunc(_states, _paths, _tfunc, _alph) {
+  static validateTFunc(_states2, _paths2, _tfunc2, _alph) {
     const newTFunc = /* @__PURE__ */ new Set();
-    for (const _t of _tfunc) {
-      if (!_states.has(_t.origin)) {
+    for (const _t of _tfunc2) {
+      if (!_states2.has(_t.origin)) {
         console.error("Origin state was invalid: %o", JSON.stringify(_t.origin));
         throw new Error(ErrorCode.ORIGIN_STATE_NOT_FOUND);
       }
-      if (!_states.has(_t.dest)) {
+      if (!_states2.has(_t.dest)) {
         console.error("Dest state was invalid: %o", JSON.stringify(_t.dest));
         throw new Error(ErrorCode.DEST_STATE_NOT_FOUND);
       }
-      const pathStateVals = getOrDefault(_paths, _t.origin, /* @__PURE__ */ new Set());
+      const pathStateVals = getOrDefault(_paths2, _t.origin, /* @__PURE__ */ new Set());
       if (this.isValidInputChar(_t.input, _alph)) {
-        if (_paths.has(_t.origin) && pathStateVals.has(_t.input)) {
+        if (_paths2.has(_t.origin) && pathStateVals.has(_t.input)) {
           newTFunc.add(_t);
           pathStateVals.delete(_t.input);
           if (pathStateVals.size === 0) {
-            _paths.delete(_t.origin);
+            _paths2.delete(_t.origin);
           }
         } else {
           throw new Error(ErrorCode.DUPLICATE_TRANSITION_OBJECT);
@@ -118,63 +118,63 @@ var DFAUtils = class {
         throw new Error(ErrorCode.INVALID_INPUT_CHAR);
       }
     }
-    if (_paths.size > 0) {
+    if (_paths2.size > 0) {
       console.error("Not all FSA paths have a transition specified:");
-      for (const [key, val] of _paths) {
+      for (const [key, val] of _paths2) {
         console.error("State %s on input(s): %s", key.name, [...val].join(" "));
       }
       throw new Error(ErrorCode.MISSING_REQUIRED_TRANSITION);
     }
     return newTFunc;
   }
-  static createPaths(_states, _alph) {
-    const _paths = /* @__PURE__ */ new Map();
-    for (const state of _states) {
+  static createPaths(_states2, _alph) {
+    const _paths2 = /* @__PURE__ */ new Map();
+    for (const state of _states2) {
       for (const char of _alph.sigma) {
-        const pathStateVals = getOrDefault(_paths, state, /* @__PURE__ */ new Set());
-        if (_paths.has(state)) pathStateVals.add(char);
-        else _paths.set(state, /* @__PURE__ */ new Set([char]));
+        const pathStateVals = getOrDefault(_paths2, state, /* @__PURE__ */ new Set());
+        if (_paths2.has(state)) pathStateVals.add(char);
+        else _paths2.set(state, /* @__PURE__ */ new Set([char]));
       }
     }
-    return _paths;
+    return _paths2;
   }
   // Determine digraph order based on start state, then following the chain
-  static determineStateOrder(_links, _tfunc, _states, _start, _accepts) {
+  static determineStateOrder(_links2, _tfunc2, _states2, _start2, _accepts2) {
     const statesOrder = [];
-    _links = /* @__PURE__ */ new Map();
-    for (const tr of _tfunc) {
-      const linkStateVals = getOrDefault(_links, tr.origin.name, /* @__PURE__ */ new Set());
-      if (_links.has(tr.origin.name)) linkStateVals.add(tr.dest.name);
-      else _links.set(tr.origin.name, /* @__PURE__ */ new Set([tr.dest.name]));
+    _links2 = /* @__PURE__ */ new Map();
+    for (const tr of _tfunc2) {
+      const linkStateVals = getOrDefault(_links2, tr.origin.name, /* @__PURE__ */ new Set());
+      if (_links2.has(tr.origin.name)) linkStateVals.add(tr.dest.name);
+      else _links2.set(tr.origin.name, /* @__PURE__ */ new Set([tr.dest.name]));
     }
-    this.parseLinks(statesOrder, _start.name, _links);
+    this.parseLinks(statesOrder, _start2.name, _links2);
     const stateArr = [];
-    Object.values([..._states]).map((state) => stateArr.push(state.name));
+    Object.values([..._states2]).map((state) => stateArr.push(state.name));
     const deadStates = stateArr.filter((x) => !statesOrder.includes(x));
     if (deadStates.length > 0) {
       console.warn("Dead states detected, removing them and associated transitions: %O", deadStates);
-      this.removeDeadStates(deadStates, _states, _accepts, _tfunc);
+      this.removeDeadStates(deadStates, _states2, _accepts2, _tfunc2);
     }
     return statesOrder;
   }
   // Reduce FSA by removing dead states and associated transitions
-  static removeDeadStates(deadStates, _states, _accepts, _tfunc) {
-    for (const state of _states) {
-      if (deadStates.indexOf(state.name) !== -1) _states.delete(state);
+  static removeDeadStates(deadStates, _states2, _accepts2, _tfunc2) {
+    for (const state of _states2) {
+      if (deadStates.indexOf(state.name) !== -1) _states2.delete(state);
     }
-    for (const state of _accepts) {
-      if (deadStates.indexOf(state.name) !== -1) _accepts.delete(state);
+    for (const state of _accepts2) {
+      if (deadStates.indexOf(state.name) !== -1) _accepts2.delete(state);
     }
-    for (const tr of _tfunc) {
-      if (deadStates.indexOf(tr.origin.name) !== -1 || deadStates.indexOf(tr.dest.name) !== -1) _tfunc.delete(tr);
+    for (const tr of _tfunc2) {
+      if (deadStates.indexOf(tr.origin.name) !== -1 || deadStates.indexOf(tr.dest.name) !== -1) _tfunc2.delete(tr);
     }
   }
   // Recursively parse graph while adding to an array in order, beginning with q0
-  static parseLinks(arr, name, _links) {
+  static parseLinks(arr, name, _links2) {
     arr.push(name);
-    const nameVal = getOrDefault(_links, name, /* @__PURE__ */ new Set());
+    const nameVal = getOrDefault(_links2, name, /* @__PURE__ */ new Set());
     for (const st of nameVal) {
-      if (arr.indexOf(st) === -1) this.parseLinks(arr, st, _links);
+      if (arr.indexOf(st) === -1) this.parseLinks(arr, st, _links2);
     }
   }
   // DFA does not allow empty symbol
@@ -184,14 +184,14 @@ var DFAUtils = class {
   }
 };
 var createDFA = (states, alphabet, transitions, start, accepts) => {
-  const _tfunc = /* @__PURE__ */ new Set();
+  const _tfunc2 = /* @__PURE__ */ new Set();
   for (const tr of transitions) {
     if (!tr.from || !tr.to || !tr.input) throw new Error(ErrorCode.INVALID_TRANSITION_OBJECT);
     const fromVal = getOrDefault(states, tr.from, null);
     const toVal = getOrDefault(states, tr.to, null);
-    _tfunc.add(new Transition(fromVal, toVal, tr.input));
+    _tfunc2.add(new Transition(fromVal, toVal, tr.input));
   }
-  return new DFA(new Set(states.values()), alphabet, _tfunc, start, accepts);
+  return new DFA(new Set(states.values()), alphabet, _tfunc2, start, accepts);
 };
 
 // src/utils/NFAUtils.ts
@@ -201,11 +201,11 @@ var NFAUtils = class extends DFAUtils {
     return _alph.sigma.indexOf(input) !== -1 || input === "";
   }
   // Follow all ε transitions and add to `state` (origin states)
-  static populateEpsilons(_tfunc, state) {
+  static populateEpsilons(_tfunc2, state) {
     let cont = true;
     while (cont) {
       cont = false;
-      const epsTransitions = Array.from(_tfunc).filter((obj) => {
+      const epsTransitions = Array.from(_tfunc2).filter((obj) => {
         return state.includes(obj.origin) && obj.input === "";
       });
       for (const _t of epsTransitions) {
@@ -218,24 +218,23 @@ var NFAUtils = class extends DFAUtils {
     return state;
   }
   // Validate tfunc according to NFA rules
-  static validateTFunc(_states, _paths, _tfunc, _alph) {
+  static validateTFunc(_states2, _paths2, _tfunc2, _alph) {
     const newTFunc = /* @__PURE__ */ new Set();
-    for (const _t of _tfunc) {
+    for (const _t of _tfunc2) {
       let skip = false;
-      if (!_states.has(_t.origin)) {
+      if (!_states2.has(_t.origin)) {
         console.error("Origin state was invalid: %o", JSON.stringify(_t.origin));
         throw new Error(ErrorCode.ORIGIN_STATE_NOT_FOUND);
       }
-      if (!_states.has(_t.dest)) {
+      if (!_states2.has(_t.dest)) {
         console.error("Dest state was invalid: %o", JSON.stringify(_t.dest));
         throw new Error(ErrorCode.DEST_STATE_NOT_FOUND);
       }
-      const pathStateVals = getOrDefault(_paths, _t.origin, /* @__PURE__ */ new Set());
       for (const _checkT of newTFunc) {
         if (_checkT.origin === _t.origin && _checkT.dest === _t.dest && _checkT.input === _t.input) skip = true;
       }
       if (!skip) {
-        if (_paths.has(_t.origin)) {
+        if (_paths2.has(_t.origin)) {
           if (this.isValidInputChar(_t.input, _alph)) {
             newTFunc.add(_t);
           } else {
@@ -248,7 +247,7 @@ var NFAUtils = class extends DFAUtils {
   }
 };
 var createNFA = (states, alphabet, transitions, start, accepts) => {
-  const _tfunc = /* @__PURE__ */ new Set();
+  const _tfunc2 = /* @__PURE__ */ new Set();
   for (const tr of transitions) {
     if (!tr.from || !tr.to || !tr.input && tr.input !== "")
       throw new Error(ErrorCode.INVALID_TRANSITION_OBJECT);
@@ -258,9 +257,9 @@ var createNFA = (states, alphabet, transitions, start, accepts) => {
     toVal.forEach((_dest) => {
       destStates.push(getOrDefault(states, _dest, null));
     });
-    _tfunc.add(new NFATransition(fromVal, destStates, tr.input));
+    _tfunc2.add(new NFATransition(fromVal, destStates, tr.input));
   }
-  return new NFA(new Set(states.values()), alphabet, _tfunc, start, accepts);
+  return new NFA(new Set(states.values()), alphabet, _tfunc2, start, accepts);
 };
 
 // src/utils/FSAUtils.ts
@@ -285,7 +284,7 @@ var FSAUtils = /* @__PURE__ */ (() => {
       });
       path = path.concat(_addToPath);
     }
-    let resultArr = [];
+    const resultArr = [];
     if (path.length > 1) {
       for (const _s of path) resultArr.push(_s.dest);
     } else if (path.length === 1) {
@@ -296,8 +295,8 @@ var FSAUtils = /* @__PURE__ */ (() => {
     const retSet = new Set(populateEpsilons(nfa.getTFunc(), resultArr));
     return retSet;
   }
-  function populateEpsilons(_tfunc, state) {
-    return NFAUtils.populateEpsilons(_tfunc, state);
+  function populateEpsilons(_tfunc2, state) {
+    return NFAUtils.populateEpsilons(_tfunc2, state);
   }
   class FSAUtils2 {
     constructor(v) {
@@ -319,42 +318,42 @@ var FSAUtils = /* @__PURE__ */ (() => {
         return receiveInputDFA(fsa, input, state);
       }
     }
-    validateTFunc(_states, _paths, _tfunc, _alph) {
+    validateTFunc(_states2, _paths2, _tfunc2, _alph) {
       if (this._type === NFA) {
-        return NFAUtils.validateTFunc(_states, _paths, _tfunc, _alph);
+        return NFAUtils.validateTFunc(_states2, _paths2, _tfunc2, _alph);
       } else {
-        return DFAUtils.validateTFunc(_states, _paths, _tfunc, _alph);
+        return DFAUtils.validateTFunc(_states2, _paths2, _tfunc2, _alph);
       }
     }
-    createPaths(_states, _alph) {
-      return DFAUtils.createPaths(_states, _alph);
+    createPaths(_states2, _alph) {
+      return DFAUtils.createPaths(_states2, _alph);
     }
-    determineStateOrder(_links, _tfunc, _states, _start, _accepts) {
-      return DFAUtils.determineStateOrder(_links, _tfunc, _states, _start, _accepts);
+    determineStateOrder(_links2, _tfunc2, _states2, _start2, _accepts2) {
+      return DFAUtils.determineStateOrder(_links2, _tfunc2, _states2, _start2, _accepts2);
     }
   }
   return FSAUtils2;
 })();
 var createFSA = (states, alphabet, transitions, start, accepts) => {
-  const _states = /* @__PURE__ */ new Map();
+  const _states2 = /* @__PURE__ */ new Map();
   if (typeof states === "string") {
-    _states.set(states, new State(states));
+    _states2.set(states, new State(states));
   } else if (Array.isArray(states)) {
     for (const state of states) {
-      if (!_states.has(state)) _states.set(state, new State(state));
+      if (!_states2.has(state)) _states2.set(state, new State(state));
     }
   } else {
     throw new TypeError(String(states));
   }
-  const _alphabet = new Alphabet(alphabet);
+  const _alphabet2 = new Alphabet(alphabet);
   if (typeof start !== "string") throw new TypeError(String(start));
-  const _start = getOrDefault(_states, start, null);
-  const _accepts = /* @__PURE__ */ new Set();
+  const _start2 = getOrDefault(_states2, start, null);
+  const _accepts2 = /* @__PURE__ */ new Set();
   if (typeof accepts === "string") {
-    if (_states.has(accepts)) _accepts.add(getOrDefault(_states, accepts, null));
+    if (_states2.has(accepts)) _accepts2.add(getOrDefault(_states2, accepts, null));
   } else if (Array.isArray(accepts)) {
     for (const state of accepts) {
-      _accepts.add(getOrDefault(_states, state, null));
+      _accepts2.add(getOrDefault(_states2, state, null));
     }
   } else {
     throw new TypeError(String(accepts));
@@ -365,130 +364,123 @@ var createFSA = (states, alphabet, transitions, start, accepts) => {
   else throw new TypeError(String(transitions));
   for (const tr of transitionList) {
     if (tr.to.indexOf(",") != -1 || tr.input === "")
-      return createNFA(_states, _alphabet, transitionList, _start, _accepts);
+      return createNFA(_states2, _alphabet2, transitionList, _start2, _accepts2);
   }
-  return createDFA(_states, _alphabet, transitionList, _start, _accepts);
+  return createDFA(_states2, _alphabet2, transitionList, _start2, _accepts2);
 };
 
 // src/automata/DFA.ts
-var DFA = /* @__PURE__ */ (() => {
-  var _states, _alphabet, _tfunc, _start, _accepts, _paths, _links, _utils;
-  class DFA3 {
-    constructor(states, alphabet, tfunc, start, accepts) {
-      // Primary FSA attributes
-      __privateAdd(this, _states);
-      __privateAdd(this, _alphabet);
-      __privateAdd(this, _tfunc);
-      __privateAdd(this, _start);
-      __privateAdd(this, _accepts);
-      // Intermediary attributes used in constructor
-      __privateAdd(this, _paths);
-      // States mapped to each member of Σ, will be empty after constructor returns
-      __privateAdd(this, _links, /* @__PURE__ */ new Map());
-      // State names mapped to their dest state names
-      __privateAdd(this, _utils);
-      __privateSet(this, _utils, new FSAUtils(this.constructor));
-      if (checkStateDuplicates(states)) throw new Error(ErrorCode.DUPLICATE_STATE_NAMES);
-      __privateSet(this, _states, states);
-      __privateSet(this, _alphabet, alphabet);
-      __privateSet(this, _paths, __privateGet(this, _utils).createPaths(__privateGet(this, _states), __privateGet(this, _alphabet)));
-      if (!states.has(start)) throw new Error(ErrorCode.START_STATE_NOT_FOUND);
-      __privateSet(this, _start, start);
-      if (Object.keys(accepts).length === 0 && accepts.constructor === Object) accepts = /* @__PURE__ */ new Set([]);
-      if (!isSubsetOf(accepts, states)) throw new Error(ErrorCode.ACCEPTS_NOT_SUBSET);
-      __privateSet(this, _accepts, accepts);
-      __privateSet(this, _tfunc, __privateGet(this, _utils).validateTFunc(__privateGet(this, _states), __privateGet(this, _paths), tfunc, __privateGet(this, _alphabet)));
-    }
-    /*
-     * Getters
-     */
-    getStates() {
-      return __privateGet(this, _states);
-    }
-    getAlphabet() {
-      return __privateGet(this, _alphabet);
-    }
-    getTFunc() {
-      return __privateGet(this, _tfunc);
-    }
-    getStartState() {
-      return __privateGet(this, _start);
-    }
-    getAcceptStates() {
-      return __privateGet(this, _accepts);
-    }
-    getType() {
-      return "DFA";
-    }
-    generateDigraph() {
-      const acceptArr = [];
-      for (const state of __privateGet(this, _accepts)) acceptArr.push(state.name);
-      const pairs = /* @__PURE__ */ new Map();
-      Object.values([...__privateGet(this, _tfunc)]).map(function(t) {
-        const key = t.origin.name + t.dest.name;
-        let _input = t.input;
-        if (_input === "") _input = "\u03B5";
-        if (!pairs.has(key)) {
-          pairs.set(key, t.origin.name + " -> " + t.dest.name + ' [ label = "' + _input + '" ];');
-        } else {
-          let _line = getOrDefault(pairs, key, "");
-          const _oldinput = _line.split('"')[1];
-          const _toAdd = _oldinput.split(",");
-          _toAdd.push(_input);
-          _toAdd.sort();
-          _line = _line.replace('"' + _oldinput + '"', '"' + _toAdd.toString() + '"');
-          pairs.set(key, _line);
-        }
-      });
-      return `digraph fsa {
+var _states, _alphabet, _tfunc, _start, _accepts, _paths, _links, _utils;
+var DFA = class {
+  constructor(states, alphabet, tfunc, start, accepts) {
+    // Primary FSA attributes
+    __privateAdd(this, _states);
+    __privateAdd(this, _alphabet);
+    __privateAdd(this, _tfunc);
+    __privateAdd(this, _start);
+    __privateAdd(this, _accepts);
+    // Intermediary attributes used in constructor
+    __privateAdd(this, _paths);
+    // States mapped to each member of Σ, will be empty after constructor returns
+    __privateAdd(this, _links, /* @__PURE__ */ new Map());
+    // State names mapped to their dest state names
+    __privateAdd(this, _utils);
+    __privateSet(this, _utils, new FSAUtils(this.constructor));
+    if (checkStateDuplicates(states)) throw new Error(ErrorCode.DUPLICATE_STATE_NAMES);
+    __privateSet(this, _states, states);
+    __privateSet(this, _alphabet, alphabet);
+    __privateSet(this, _paths, __privateGet(this, _utils).createPaths(__privateGet(this, _states), __privateGet(this, _alphabet)));
+    if (!states.has(start)) throw new Error(ErrorCode.START_STATE_NOT_FOUND);
+    __privateSet(this, _start, start);
+    if (Object.keys(accepts).length === 0 && accepts.constructor === Object) accepts = /* @__PURE__ */ new Set([]);
+    if (!isSubsetOf(accepts, states)) throw new Error(ErrorCode.ACCEPTS_NOT_SUBSET);
+    __privateSet(this, _accepts, accepts);
+    __privateSet(this, _tfunc, __privateGet(this, _utils).validateTFunc(__privateGet(this, _states), __privateGet(this, _paths), tfunc, __privateGet(this, _alphabet)));
+  }
+  /*
+   * Getters
+   */
+  getStates() {
+    return __privateGet(this, _states);
+  }
+  getAlphabet() {
+    return __privateGet(this, _alphabet);
+  }
+  getTFunc() {
+    return __privateGet(this, _tfunc);
+  }
+  getStartState() {
+    return __privateGet(this, _start);
+  }
+  getAcceptStates() {
+    return __privateGet(this, _accepts);
+  }
+  getType() {
+    return "DFA";
+  }
+  generateDigraph() {
+    const acceptArr = [];
+    for (const state of __privateGet(this, _accepts)) acceptArr.push(state.name);
+    const pairs = /* @__PURE__ */ new Map();
+    Object.values([...__privateGet(this, _tfunc)]).map(function(t) {
+      const key = t.origin.name + t.dest.name;
+      let _input = t.input;
+      if (_input === "") _input = "\u03B5";
+      if (!pairs.has(key)) {
+        pairs.set(key, t.origin.name + " -> " + t.dest.name + ' [ label = "' + _input + '" ];');
+      } else {
+        let _line = getOrDefault(pairs, key, "");
+        const _oldinput = _line.split('"')[1];
+        const _toAdd = _oldinput.split(",");
+        _toAdd.push(_input);
+        _toAdd.sort();
+        _line = _line.replace('"' + _oldinput + '"', '"' + _toAdd.toString() + '"');
+        pairs.set(key, _line);
+      }
+    });
+    return `digraph fsa {
           ${Object.values(
-        __privateGet(this, _utils).determineStateOrder(__privateGet(this, _links), __privateGet(this, _tfunc), __privateGet(this, _states), __privateGet(this, _start), __privateGet(this, _accepts))
-      ).map(function(str) {
-        if (acceptArr.indexOf(str) !== -1) return str + " [shape = doublecircle];";
-        else return str;
-      }).join("\n	")}
+      __privateGet(this, _utils).determineStateOrder(__privateGet(this, _links), __privateGet(this, _tfunc), __privateGet(this, _states), __privateGet(this, _start), __privateGet(this, _accepts))
+    ).map(function(str) {
+      if (acceptArr.indexOf(str) !== -1) return str + " [shape = doublecircle];";
+      else return str;
+    }).join("\n	")}
           rankdir=LR;
           node [shape = point ]; qi;
           node [shape = circle];
           qi -> ${__privateGet(this, _start).name};
           ${Object.values([...pairs]).map(function([, val]) {
-        return val;
-      }).join("\n	")}
+      return val;
+    }).join("\n	")}
       }
       `;
-    }
   }
-  _states = new WeakMap();
-  _alphabet = new WeakMap();
-  _tfunc = new WeakMap();
-  _start = new WeakMap();
-  _accepts = new WeakMap();
-  _paths = new WeakMap();
-  _links = new WeakMap();
-  _utils = new WeakMap();
-  return DFA3;
-})();
+};
+_states = new WeakMap();
+_alphabet = new WeakMap();
+_tfunc = new WeakMap();
+_start = new WeakMap();
+_accepts = new WeakMap();
+_paths = new WeakMap();
+_links = new WeakMap();
+_utils = new WeakMap();
 
 // src/automata/NFA.ts
-var NFA = /* @__PURE__ */ (() => {
-  class NFA2 extends DFA {
-    // Transition function is different for NFA
-    constructor(states, alphabet, tfunc, start, accepts) {
-      if (!alphabet.sigma.includes("")) alphabet.sigma.push("");
-      const expandedTfunc = /* @__PURE__ */ new Set();
-      for (const _t of tfunc) {
-        _t.dest.forEach((_dest) => {
-          expandedTfunc.add(new Transition(_t.origin, _dest, _t.input));
-        });
-      }
-      super(states, alphabet, expandedTfunc, start, accepts);
-    }
-    getType() {
-      return "NFA";
+var NFA = class extends DFA {
+  constructor(states, alphabet, tfunc, start, accepts) {
+    if (!alphabet.sigma.includes("")) alphabet.sigma.push("");
+    const expandedTfunc = /* @__PURE__ */ new Set();
+    for (const _t of tfunc) {
+      _t.dest.forEach((_dest) => {
+        expandedTfunc.add(new Transition(_t.origin, _dest, _t.input));
+      });
     }
+    super(states, alphabet, expandedTfunc, start, accepts);
   }
-  return NFA2;
-})();
+  getType() {
+    return "NFA";
+  }
+};
 
 // src/engine/Simulators.ts
 var simulateFSA = (w, fsa, logging = false, returnEndState = false) => {