fas-js 1.3.2 → 1.4.0

package/lib/index.cjs

@@ -0,0 +1,644 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/modules.ts
+var modules_exports = {};
+__export(modules_exports, {
+  createFSA: () => createFSA,
+  simulateFSA: () => simulateFSA,
+  stepOnceFSA: () => stepOnceFSA
+});
+module.exports = __toCommonJS(modules_exports);
+
+// src/globals/errors.ts
+var ErrorCode = Object.freeze({
+  DUPLICATE_ALPHABET_VALS: "E-001",
+  DUPLICATE_STATE_NAMES: "E-002",
+  INVALID_STATE_NAME: "E-003",
+  START_STATE_NOT_FOUND: "E-004",
+  ACCEPTS_NOT_SUBSET: "E-005",
+  ORIGIN_STATE_NOT_FOUND: "E-006",
+  DEST_STATE_NOT_FOUND: "E-007",
+  MISSING_REQUIRED_TRANSITION: "E-008",
+  INVALID_INPUT_CHAR: "E-009",
+  INPUT_STATE_NOT_FOUND: "E-010",
+  INVALID_TRANSITION_OBJECT: "E-011",
+  DUPLICATE_TRANSITION_OBJECT: "E-012",
+  INVALID_STATE_ARRAY: "E-013"
+});
+
+// src/components/State.ts
+var State = class {
+  constructor(name) {
+    this.name = name;
+    if (!this.name) throw new Error(ErrorCode.INVALID_STATE_NAME);
+  }
+};
+
+// src/globals/globals.ts
+var count = (names) => names.reduce((a, b) => Object.assign(a, { [b]: (a[b] || 0) + 1 }), {});
+var duplicates = (dict) => Object.keys(dict).filter((a) => dict[a] > 1);
+var checkStateDuplicates = (states) => {
+  const check = /* @__PURE__ */ new Set();
+  for (const item of states) {
+    if (check.has(item.name)) return true;
+    check.add(item.name);
+  }
+  return false;
+};
+var getOrDefault = (map, key, defaultValue) => {
+  const val = map.get(key);
+  return val == null ? defaultValue : val;
+};
+var instanceOf = (ctor, obj) => {
+  return obj instanceof ctor || Boolean(ctor.name) && ctor.name === obj.constructor.name;
+};
+var isSubsetOf = (subset, superset) => {
+  for (const item of subset) {
+    if (!superset.has(item)) return false;
+  }
+  return true;
+};
+
+// src/components/Alphabet.ts
+var Alphabet = class {
+  constructor(sigma) {
+    if (!Array.isArray(sigma)) {
+      if (typeof sigma === "string") sigma = [...sigma];
+      else throw new TypeError();
+    }
+    this.sigma = sigma;
+    if (duplicates(count(this.sigma)).length > 0) throw new Error(ErrorCode.DUPLICATE_ALPHABET_VALS);
+  }
+};
+
+// src/components/NFATransition.ts
+var NFATransition = class {
+  constructor(origin, dest, input) {
+    this.origin = origin;
+    this.dest = dest;
+    this.input = input;
+  }
+};
+
+// src/components/Transition.ts
+var Transition = class {
+  constructor(origin, dest, input) {
+    this.origin = origin;
+    this.dest = dest;
+    this.input = input;
+  }
+};
+
+// src/utils/DFAUtils.ts
+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) {
+    const newTFunc = /* @__PURE__ */ new Set();
+    for (const _t of _tfunc) {
+      if (!_states.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)) {
+        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());
+      if (this.isValidInputChar(_t.input, _alph)) {
+        if (_paths.has(_t.origin) && pathStateVals.has(_t.input)) {
+          newTFunc.add(_t);
+          pathStateVals.delete(_t.input);
+          if (pathStateVals.size === 0) {
+            _paths.delete(_t.origin);
+          }
+        } else {
+          throw new Error(ErrorCode.DUPLICATE_TRANSITION_OBJECT);
+        }
+      } else {
+        throw new Error(ErrorCode.INVALID_INPUT_CHAR);
+      }
+    }
+    if (_paths.size > 0) {
+      console.error("Not all FSA paths have a transition specified:");
+      for (const [key, val] of _paths) {
+        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) {
+      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]));
+      }
+    }
+    return _paths;
+  }
+  // Determine digraph order based on start state, then following the chain
+  static determineStateOrder(_links, _tfunc, _states, _start, _accepts) {
+    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]));
+    }
+    this.parseLinks(statesOrder, _start.name, _links);
+    const stateArr = [];
+    Object.values([..._states]).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);
+    }
+    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);
+    }
+    for (const state of _accepts) {
+      if (deadStates.indexOf(state.name) !== -1) _accepts.delete(state);
+    }
+    for (const tr of _tfunc) {
+      if (deadStates.indexOf(tr.origin.name) !== -1 || deadStates.indexOf(tr.dest.name) !== -1) _tfunc.delete(tr);
+    }
+  }
+  // Recursively parse graph while adding to an array in order, beginning with q0
+  static parseLinks(arr, name, _links) {
+    arr.push(name);
+    const nameVal = getOrDefault(_links, name, /* @__PURE__ */ new Set());
+    for (const st of nameVal) {
+      if (arr.indexOf(st) === -1) this.parseLinks(arr, st, _links);
+    }
+  }
+  // DFA does not allow empty symbol
+  static isValidInputChar(input, _alph) {
+    if (input === "") return false;
+    return _alph.sigma.indexOf(input) !== -1;
+  }
+};
+var createDFA = (states, alphabet, transitions, start, accepts) => {
+  const _tfunc = /* @__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));
+  }
+  return new DFA(new Set(states.values()), alphabet, _tfunc, start, accepts);
+};
+
+// src/utils/NFAUtils.ts
+var NFAUtils = class extends DFAUtils {
+  // NFA inheritly allows for ε (empty string) transition if specified
+  static isValidInputChar(input, _alph) {
+    return _alph.sigma.indexOf(input) !== -1 || input === "";
+  }
+  // Follow all ε transitions and add to `state` (origin states)
+  static populateEpsilons(_tfunc, state) {
+    let cont = true;
+    while (cont) {
+      cont = false;
+      const epsTransitions = Array.from(_tfunc).filter((obj) => {
+        return state.includes(obj.origin) && obj.input === "";
+      });
+      for (const _t of epsTransitions) {
+        if (!state.includes(_t.dest)) {
+          state.push(_t.dest);
+          cont = true;
+        }
+      }
+    }
+    return state;
+  }
+  // Validate tfunc according to NFA rules
+  static validateTFunc(_states, _paths, _tfunc, _alph) {
+    const newTFunc = /* @__PURE__ */ new Set();
+    for (const _t of _tfunc) {
+      let skip = false;
+      if (!_states.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)) {
+        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 (this.isValidInputChar(_t.input, _alph)) {
+            newTFunc.add(_t);
+          } else {
+            throw new Error(ErrorCode.INVALID_INPUT_CHAR);
+          }
+        }
+      }
+    }
+    return newTFunc;
+  }
+};
+var createNFA = (states, alphabet, transitions, start, accepts) => {
+  const _tfunc = /* @__PURE__ */ new Set();
+  for (const tr of transitions) {
+    if (!tr.from || !tr.to || !tr.input && tr.input !== "")
+      throw new Error(ErrorCode.INVALID_TRANSITION_OBJECT);
+    const fromVal = getOrDefault(states, tr.from, null);
+    const toVal = tr.to.split(",");
+    const destStates = [];
+    toVal.forEach((_dest) => {
+      destStates.push(getOrDefault(states, _dest, null));
+    });
+    _tfunc.add(new NFATransition(fromVal, destStates, tr.input));
+  }
+  return new NFA(new Set(states.values()), alphabet, _tfunc, start, accepts);
+};
+
+// src/utils/FSAUtils.ts
+var FSAUtils = /* @__PURE__ */ (() => {
+  function receiveInputDFA(dfa, input, state) {
+    if (dfa.getAlphabet().sigma.indexOf(input) === -1) throw new Error(ErrorCode.INVALID_INPUT_CHAR);
+    if (!dfa.getStates().has(state)) throw new Error(ErrorCode.INPUT_STATE_NOT_FOUND);
+    const path = Array.from(dfa.getTFunc()).find((obj) => {
+      return obj.origin === state && obj.input === input;
+    });
+    if (path) return path.dest;
+    else throw new Error(ErrorCode.INVALID_TRANSITION_OBJECT);
+  }
+  function receiveInputNFA(nfa, input, state) {
+    let path = [];
+    if (nfa.getAlphabet().sigma.indexOf(input) === -1) throw new Error(ErrorCode.INVALID_INPUT_CHAR);
+    state = populateEpsilons(nfa.getTFunc(), state);
+    if (input === "") return new Set(state);
+    for (const _s of state) {
+      const _addToPath = Array.from(nfa.getTFunc()).filter((obj) => {
+        return obj.origin === _s && obj.input === input;
+      });
+      path = path.concat(_addToPath);
+    }
+    let resultArr = [];
+    if (path.length > 1) {
+      for (const _s of path) resultArr.push(_s.dest);
+    } else if (path.length === 1) {
+      resultArr.push(path[0].dest);
+    } else {
+      return /* @__PURE__ */ new Set();
+    }
+    const retSet = new Set(populateEpsilons(nfa.getTFunc(), resultArr));
+    return retSet;
+  }
+  function populateEpsilons(_tfunc, state) {
+    return NFAUtils.populateEpsilons(_tfunc, state);
+  }
+  class FSAUtils2 {
+    constructor(v) {
+      this._type = v;
+    }
+    receiveInput(fsa, input, state) {
+      if (instanceOf(NFA, fsa)) {
+        if (state instanceof State) return receiveInputNFA(fsa, input, [state]);
+        else return receiveInputNFA(fsa, input, state);
+      } else {
+        if (Array.isArray(state)) {
+          if (state.length > 1) {
+            console.error("State array can only contain one state for DFAs");
+            throw new Error(ErrorCode.INVALID_STATE_ARRAY);
+          } else {
+            state = state[0];
+          }
+        }
+        return receiveInputDFA(fsa, input, state);
+      }
+    }
+    validateTFunc(_states, _paths, _tfunc, _alph) {
+      if (this._type === NFA) {
+        return NFAUtils.validateTFunc(_states, _paths, _tfunc, _alph);
+      } else {
+        return DFAUtils.validateTFunc(_states, _paths, _tfunc, _alph);
+      }
+    }
+    createPaths(_states, _alph) {
+      return DFAUtils.createPaths(_states, _alph);
+    }
+    determineStateOrder(_links, _tfunc, _states, _start, _accepts) {
+      return DFAUtils.determineStateOrder(_links, _tfunc, _states, _start, _accepts);
+    }
+  }
+  return FSAUtils2;
+})();
+var createFSA = (states, alphabet, transitions, start, accepts) => {
+  const _states = /* @__PURE__ */ new Map();
+  if (typeof states === "string") {
+    _states.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));
+    }
+  } else {
+    throw new TypeError(String(states));
+  }
+  const _alphabet = new Alphabet(alphabet);
+  if (typeof start !== "string") throw new TypeError(String(start));
+  const _start = getOrDefault(_states, start, null);
+  const _accepts = /* @__PURE__ */ new Set();
+  if (typeof accepts === "string") {
+    if (_states.has(accepts)) _accepts.add(getOrDefault(_states, accepts, null));
+  } else if (Array.isArray(accepts)) {
+    for (const state of accepts) {
+      _accepts.add(getOrDefault(_states, state, null));
+    }
+  } else {
+    throw new TypeError(String(accepts));
+  }
+  let transitionList;
+  if (!Array.isArray(transitions) && typeof transitions === "object") transitionList = [transitions];
+  else if (Array.isArray(transitions)) transitionList = transitions;
+  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 createDFA(_states, _alphabet, transitionList, _start, _accepts);
+};
+
+// 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 {
+          ${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	")}
+          rankdir=LR;
+          node [shape = point ]; qi;
+          node [shape = circle];
+          qi -> ${__privateGet(this, _start).name};
+          ${Object.values([...pairs]).map(function([, val]) {
+        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;
+})();
+
+// 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";
+    }
+  }
+  return NFA2;
+})();
+
+// src/engine/Simulators.ts
+var simulateFSA = (w, fsa, logging = false, returnEndState = false) => {
+  if (instanceOf(NFA, fsa)) {
+    return simulateNFA(w, fsa, new FSAUtils(NFA), logging, returnEndState);
+  } else {
+    return simulateDFA(w, fsa, new FSAUtils(DFA), logging, returnEndState);
+  }
+};
+var stepOnceFSA = (w, qin, fsa, logging = false) => {
+  if (typeof w !== "string") {
+    if (logging) console.error("Input w was invalid type: %O", w);
+    throw new TypeError();
+  }
+  if (typeof qin !== "string" && !Array.isArray(qin)) {
+    if (logging) console.error("Input state was invalid type: %O", qin);
+    throw new TypeError();
+  }
+  if (logging) console.log("Input Processing Started");
+  let prevState = [];
+  if (typeof qin === "string") {
+    for (const state of fsa.getStates().values()) {
+      if (qin === state.name) prevState = state;
+    }
+    if (!prevState || Array.isArray(prevState) && prevState.length === 0)
+      throw new Error(ErrorCode.INVALID_STATE_NAME);
+  } else {
+    prevState = [];
+    for (const state of fsa.getStates().values()) {
+      if (qin.includes(state.name)) prevState.push(state);
+    }
+    if (prevState.length !== qin.length) {
+      throw new Error(ErrorCode.INVALID_STATE_NAME);
+    }
+  }
+  let newState;
+  if (instanceOf(NFA, fsa)) newState = [...new FSAUtils(NFA).receiveInput(fsa, w, prevState)];
+  else newState = new FSAUtils(DFA).receiveInput(fsa, w, prevState);
+  if (logging) console.log("%o x '%s' -> %o", JSON.stringify(prevState), w, JSON.stringify(newState));
+  if (logging) console.log("Input Processing Ended");
+  if (newState instanceof State) return newState.name;
+  else {
+    const retArray = [];
+    for (const _s of newState) {
+      retArray.push(_s.name);
+    }
+    return retArray;
+  }
+};
+function simulateDFA(w, dfa, utils, logging, returnEndState) {
+  if (logging) console.log("Beginning DFA Simulation");
+  if (!Array.isArray(w)) {
+    if (typeof w === "string") w = [...w];
+    else {
+      if (logging) console.error("Input w was invalid type: %O", w);
+      throw new TypeError();
+    }
+  }
+  if (logging) console.log("Input Processing Started");
+  let currentState = dfa.getStartState();
+  for (const char of w) {
+    const prevState = currentState;
+    currentState = utils.receiveInput(dfa, char, prevState);
+    if (logging) console.log("%o x '%s' -> %o", JSON.stringify(prevState), char, JSON.stringify(currentState));
+  }
+  if (logging) console.log("Input Processing Ended");
+  if (dfa.getAcceptStates().has(currentState)) {
+    if (logging) console.log("Input Accepted!");
+    if (returnEndState) return currentState.name;
+    else return true;
+  } else {
+    if (logging) console.log("Input Rejected!");
+    if (returnEndState) return currentState.name;
+    else return false;
+  }
+}
+function simulateNFA(w, nfa, utils, logging, returnEndState) {
+  if (logging) console.log("Beginning NFA Simulation");
+  if (!(w instanceof Array)) {
+    if (typeof w === "string") {
+      if (w === "") w = [""];
+      else w = [...w];
+    } else {
+      if (logging) console.error("Input w was invalid type: %O", w);
+      throw new TypeError();
+    }
+  }
+  if (logging) console.log("Input Processing Started");
+  let currentState = [nfa.getStartState()];
+  for (const char of w) {
+    const prevState = currentState;
+    currentState = [...utils.receiveInput(nfa, char, currentState)];
+    if (logging) console.log("%o x '%s' -> %o", JSON.stringify(prevState), char, JSON.stringify(currentState));
+  }
+  if (logging) console.log("Input Processing Ended");
+  const retObj = [];
+  for (const _accState of nfa.getAcceptStates()) {
+    if (currentState.includes(_accState)) {
+      if (!returnEndState) {
+        if (logging) console.log("Input Accepted!");
+        return true;
+      }
+      retObj.push(_accState.name);
+    }
+  }
+  if (retObj.length > 0) {
+    if (logging) console.log("Input Accepted!");
+    return retObj;
+  }
+  if (logging) console.log("Input Rejected!");
+  if (returnEndState) {
+    if (currentState.length > 0) {
+      for (const _cState of currentState) retObj.push(_cState.name);
+    }
+    return retObj;
+  } else {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFSA,
+  simulateFSA,
+  stepOnceFSA
+});
+//# sourceMappingURL=index.cjs.map