fas-js 1.3.2 → 1.5.0

package/lib/demo-bundle.js

@@ -0,0 +1,12 @@
+"use strict";var fasJs=(()=>{var q=Object.defineProperty;var ht=Object.getOwnPropertyDescriptor;var At=Object.getOwnPropertyNames;var Tt=Object.prototype.hasOwnProperty;var ot=o=>{throw TypeError(o)};var dt=(o,t)=>{for(var e in t)q(o,e,{get:t[e],enumerable:!0})},yt=(o,t,e,r)=>{if(t&&typeof t=="object"||typeof t=="function")for(let s of At(t))!Tt.call(o,s)&&s!==e&&q(o,s,{get:()=>t[s],enumerable:!(r=ht(t,s))||r.enumerable});return o};var bt=o=>yt(q({},"__esModule",{value:!0}),o);var st=(o,t,e)=>t.has(o)||ot("Cannot "+e);var u=(o,t,e)=>(st(o,t,"read from private field"),e?e.call(o):t.get(o)),h=(o,t,e)=>t.has(o)?ot("Cannot add the same private member more than once"):t instanceof WeakSet?t.add(o):t.set(o,e),A=(o,t,e,r)=>(st(o,t,"write to private field"),r?r.call(o,e):t.set(o,e),e);var Ot={};dt(Ot,{RegularLanguage:()=>$,createFSA:()=>k,simulateFSA:()=>j,stepOnceFSA:()=>tt});var f=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"});var I=class{constructor(t){if(this.name=t,!this.name)throw new Error(f.INVALID_STATE_NAME)}};var it=o=>o.reduce((t,e)=>Object.assign(t,{[e]:(t[e]||0)+1}),{}),at=o=>Object.keys(o).filter(t=>o[t]>1);var ct=o=>{let t=new Set;for(let e of o){if(t.has(e.name))return!0;t.add(e.name)}return!1},S=(o,t,e)=>{let r=o.get(t);return r??e},y=(o,t)=>t instanceof o||!!o.name&&o.name===t.constructor.name,pt=(o,t)=>{for(let e of o)if(!t.has(e))return!1;return!0};var G=class{constructor(t){if(!Array.isArray(t))if(typeof t=="string")t=[...t];else throw new TypeError;if(this.sigma=t,at(it(this.sigma)).length>0)throw new Error(f.DUPLICATE_ALPHABET_VALS)}};var K=class{constructor(t,e,r){this.origin=t,this.dest=e,this.input=r}};var C=class{constructor(t,e,r){this.origin=t,this.dest=e,this.input=r}};var F=class{static validateTFunc(t,e,r,s){let n=new Set;for(let i of r){if(!t.has(i.origin))throw console.error("Origin state was invalid: %o",JSON.stringify(i.origin)),new Error(f.ORIGIN_STATE_NOT_FOUND);if(!t.has(i.dest))throw console.error("Dest state was invalid: %o",JSON.stringify(i.dest)),new Error(f.DEST_STATE_NOT_FOUND);let a=S(e,i.origin,new Set);if(this.isValidInputChar(i.input,s))if(e.has(i.origin)&&a.has(i.input))n.add(i),a.delete(i.input),a.size===0&&e.delete(i.origin);else throw new Error(f.DUPLICATE_TRANSITION_OBJECT);else throw new Error(f.INVALID_INPUT_CHAR)}if(e.size>0){console.error("Not all FSA paths have a transition specified:");for(let[i,a]of e)console.error("State %s on input(s): %s",i.name,[...a].join(" "));throw new Error(f.MISSING_REQUIRED_TRANSITION)}return n}static createPaths(t,e){let r=new Map;for(let s of t)for(let n of e.sigma){let i=S(r,s,new Set);r.has(s)?i.add(n):r.set(s,new Set([n]))}return r}static determineStateOrder(t,e,r,s,n){let i=[];t=new Map;for(let p of e){let l=S(t,p.origin.name,new Set);t.has(p.origin.name)?l.add(p.dest.name):t.set(p.origin.name,new Set([p.dest.name]))}this.parseLinks(i,s.name,t);let a=[];Object.values([...r]).map(p=>a.push(p.name));let c=a.filter(p=>!i.includes(p));return c.length>0&&(console.warn("Dead states detected, removing them and associated transitions: %O",c),this.removeDeadStates(c,r,n,e)),i}static removeDeadStates(t,e,r,s){for(let n of e)t.indexOf(n.name)!==-1&&e.delete(n);for(let n of r)t.indexOf(n.name)!==-1&&r.delete(n);for(let n of s)(t.indexOf(n.origin.name)!==-1||t.indexOf(n.dest.name)!==-1)&&s.delete(n)}static parseLinks(t,e,r){t.push(e);let s=S(r,e,new Set);for(let n of s)t.indexOf(n)===-1&&this.parseLinks(t,n,r)}static isValidInputChar(t,e){return t===""?!1:e.sigma.indexOf(t)!==-1}},ft=(o,t,e,r,s)=>{let n=new Set;for(let i of e){if(!i.from||!i.to||!i.input)throw new Error(f.INVALID_TRANSITION_OBJECT);let a=S(o,i.from,null),c=S(o,i.to,null);n.add(new C(a,c,i.input))}return new b(new Set(o.values()),t,n,r,s)};var V=class extends F{static isValidInputChar(t,e){return e.sigma.indexOf(t)!==-1||t===""}static populateEpsilons(t,e){let r=!0;for(;r;){r=!1;let s=Array.from(t).filter(n=>e.includes(n.origin)&&n.input==="");for(let n of s)e.includes(n.dest)||(e.push(n.dest),r=!0)}return e}static validateTFunc(t,e,r,s){let n=new Set;for(let i of r){let a=!1;if(!t.has(i.origin))throw console.error("Origin state was invalid: %o",JSON.stringify(i.origin)),new Error(f.ORIGIN_STATE_NOT_FOUND);if(!t.has(i.dest))throw console.error("Dest state was invalid: %o",JSON.stringify(i.dest)),new Error(f.DEST_STATE_NOT_FOUND);for(let c of n)c.origin===i.origin&&c.dest===i.dest&&c.input===i.input&&(a=!0);if(!a&&e.has(i.origin))if(this.isValidInputChar(i.input,s))n.add(i);else throw new Error(f.INVALID_INPUT_CHAR)}return n}},ut=(o,t,e,r,s)=>{let n=new Set;for(let i of e){if(!i.from||!i.to||!i.input&&i.input!=="")throw new Error(f.INVALID_TRANSITION_OBJECT);let a=S(o,i.from,null),c=i.to.split(","),p=[];c.forEach(l=>{p.push(S(o,l,null))}),n.add(new K(a,p,i.input))}return new g(new Set(o.values()),t,n,r,s)};var E=(()=>{function o(s,n,i){if(s.getAlphabet().sigma.indexOf(n)===-1)throw new Error(f.INVALID_INPUT_CHAR);if(!s.getStates().has(i))throw new Error(f.INPUT_STATE_NOT_FOUND);let a=Array.from(s.getTFunc()).find(c=>c.origin===i&&c.input===n);if(a)return a.dest;throw new Error(f.INVALID_TRANSITION_OBJECT)}function t(s,n,i){let a=[];if(s.getAlphabet().sigma.indexOf(n)===-1)throw new Error(f.INVALID_INPUT_CHAR);if(i=e(s.getTFunc(),i),n==="")return new Set(i);for(let l of i){let U=Array.from(s.getTFunc()).filter(d=>d.origin===l&&d.input===n);a=a.concat(U)}let c=[];if(a.length>1)for(let l of a)c.push(l.dest);else if(a.length===1)c.push(a[0].dest);else return new Set;return new Set(e(s.getTFunc(),c))}function e(s,n){return V.populateEpsilons(s,n)}class r{constructor(n){this._type=n}receiveInput(n,i,a){if(y(g,n))return a instanceof I?t(n,i,[a]):t(n,i,a);if(Array.isArray(a)){if(a.length>1)throw console.error("State array can only contain one state for DFAs"),new Error(f.INVALID_STATE_ARRAY);a=a[0]}return o(n,i,a)}validateTFunc(n,i,a,c){return this._type===g?V.validateTFunc(n,i,a,c):F.validateTFunc(n,i,a,c)}createPaths(n,i){return F.createPaths(n,i)}determineStateOrder(n,i,a,c,p){return F.determineStateOrder(n,i,a,c,p)}}return r})(),k=(o,t,e,r,s)=>{let n=new Map;if(typeof o=="string")n.set(o,new I(o));else if(Array.isArray(o))for(let l of o)n.has(l)||n.set(l,new I(l));else throw new TypeError(String(o));let i=new G(t);if(typeof r!="string")throw new TypeError(String(r));let a=S(n,r,null),c=new Set;if(typeof s=="string")n.has(s)&&c.add(S(n,s,null));else if(Array.isArray(s))for(let l of s)c.add(S(n,l,null));else throw new TypeError(String(s));let p;if(!Array.isArray(e)&&typeof e=="object")p=[e];else if(Array.isArray(e))p=e;else throw new TypeError(String(e));for(let l of p)if(l.to.indexOf(",")!=-1||l.input==="")return ut(n,i,p,a,c);return ft(n,i,p,a,c)};var w,D,O,_,x,P,Q,R,b=class{constructor(t,e,r,s,n){h(this,w);h(this,D);h(this,O);h(this,_);h(this,x);h(this,P);h(this,Q,new Map);h(this,R);if(A(this,R,new E(this.constructor)),ct(t))throw new Error(f.DUPLICATE_STATE_NAMES);if(A(this,w,t),A(this,D,e),A(this,P,u(this,R).createPaths(u(this,w),u(this,D))),!t.has(s))throw new Error(f.START_STATE_NOT_FOUND);if(A(this,_,s),Object.keys(n).length===0&&n.constructor===Object&&(n=new Set([])),!pt(n,t))throw new Error(f.ACCEPTS_NOT_SUBSET);A(this,x,n),A(this,O,u(this,R).validateTFunc(u(this,w),u(this,P),r,u(this,D)))}getStates(){return u(this,w)}getAlphabet(){return u(this,D)}getTFunc(){return u(this,O)}getStartState(){return u(this,_)}getAcceptStates(){return u(this,x)}getType(){return"DFA"}generateDigraph(){let t=[];for(let r of u(this,x))t.push(r.name);let e=new Map;return Object.values([...u(this,O)]).map(function(r){let s=r.origin.name+r.dest.name,n=r.input;if(n===""&&(n="\u03B5"),!e.has(s))e.set(s,r.origin.name+" -> "+r.dest.name+' [ label = "'+n+'" ];');else{let i=S(e,s,""),a=i.split('"')[1],c=a.split(",");c.push(n),c.sort(),i=i.replace('"'+a+'"','"'+c.toString()+'"'),e.set(s,i)}}),`digraph fsa {
+          ${Object.values(u(this,R).determineStateOrder(u(this,Q),u(this,O),u(this,w),u(this,_),u(this,x))).map(function(r){return t.indexOf(r)!==-1?r+" [shape = doublecircle];":r}).join(`
+	`)}
+          rankdir=LR;
+          node [shape = point ]; qi;
+          node [shape = circle];
+          qi -> ${u(this,_).name};
+          ${Object.values([...e]).map(function([,r]){return r}).join(`
+	`)}
+      }
+      `}};w=new WeakMap,D=new WeakMap,O=new WeakMap,_=new WeakMap,x=new WeakMap,P=new WeakMap,Q=new WeakMap,R=new WeakMap;var g=class extends b{constructor(t,e,r,s,n){e.sigma.includes("")||e.sigma.push("");let i=new Set;for(let a of r)a.dest.forEach(c=>{i.add(new C(a.origin,c,a.input))});super(t,e,i,s,n)}getType(){return"NFA"}};var j=(o,t,e=!1,r=!1)=>y(g,t)?Ft(o,t,new E(g),e,r):It(o,t,new E(b),e,r),tt=(o,t,e,r=!1)=>{if(typeof o!="string")throw r&&console.error("Input w was invalid type: %O",o),new TypeError;if(typeof t!="string"&&!Array.isArray(t))throw r&&console.error("Input state was invalid type: %O",t),new TypeError;r&&console.log("Input Processing Started");let s=[];if(typeof t=="string"){for(let i of e.getStates().values())t===i.name&&(s=i);if(!s||Array.isArray(s)&&s.length===0)throw new Error(f.INVALID_STATE_NAME)}else{s=[];for(let i of e.getStates().values())t.includes(i.name)&&s.push(i);if(s.length!==t.length)throw new Error(f.INVALID_STATE_NAME)}let n;if(y(g,e)?n=[...new E(g).receiveInput(e,o,s)]:n=new E(b).receiveInput(e,o,s),r&&console.log("%o x '%s' -> %o",JSON.stringify(s),o,JSON.stringify(n)),r&&console.log("Input Processing Ended"),n instanceof I)return n.name;{let i=[];for(let a of n)i.push(a.name);return i}};function It(o,t,e,r,s){if(r&&console.log("Beginning DFA Simulation"),!Array.isArray(o))if(typeof o=="string")o=[...o];else throw r&&console.error("Input w was invalid type: %O",o),new TypeError;r&&console.log("Input Processing Started");let n=t.getStartState();for(let i of o){let a=n;n=e.receiveInput(t,i,a),r&&console.log("%o x '%s' -> %o",JSON.stringify(a),i,JSON.stringify(n))}return r&&console.log("Input Processing Ended"),t.getAcceptStates().has(n)?(r&&console.log("Input Accepted!"),s?n.name:!0):(r&&console.log("Input Rejected!"),s?n.name:!1)}function Ft(o,t,e,r,s){if(r&&console.log("Beginning NFA Simulation"),!(o instanceof Array))if(typeof o=="string")o===""?o=[""]:o=[...o];else throw r&&console.error("Input w was invalid type: %O",o),new TypeError;r&&console.log("Input Processing Started");let n=[t.getStartState()];for(let a of o){let c=n;n=[...e.receiveInput(t,a,n)],r&&console.log("%o x '%s' -> %o",JSON.stringify(c),a,JSON.stringify(n))}r&&console.log("Input Processing Ended");let i=[];for(let a of t.getAcceptStates())if(n.includes(a)){if(!s)return r&&console.log("Input Accepted!"),!0;i.push(a.name)}if(i.length>0)return r&&console.log("Input Accepted!"),i;if(r&&console.log("Input Rejected!"),s){if(n.length>0)for(let a of n)i.push(a.name);return i}else return!1}var J=class{};function B(o){return o.getAlphabet().sigma.filter(t=>t!=="").sort()}function et(o,t){return[...new Set([...o,...t])].sort()}function lt(o){let t=[...o.getStates()].map(a=>a.name).sort(),e=B(o),r=[...o.getAcceptStates()].map(a=>a.name).sort(),s=o.getStartState().name,n=new Map;for(let a of o.getTFunc()){let c=`${a.origin.name}\0${a.input}`,p=n.get(c)??new Set;p.add(a.dest.name),n.set(c,p)}let i=[];for(let[a,c]of n){let[p,l]=a.split("\0");i.push({from:p,to:[...c].sort().join(","),input:l})}return i.sort((a,c)=>{let p=a.from.localeCompare(c.from);return p!==0?p:a.input.localeCompare(c.input)}),{states:t,alphabet:e,transitions:i,start:s,accepts:r}}function v(o,t){let e=r=>`${t}${r}`;return{states:o.states.map(e),alphabet:[...o.alphabet],start:e(o.start),accepts:o.accepts.map(e),transitions:o.transitions.map(r=>({from:e(r.from),to:r.to.split(",").map(s=>e(s.trim())).join(","),input:r.input}))}}function H(o){return k(o.states,o.alphabet,o.transitions,o.start,o.accepts)}function wt(o,t){let e=v(o,"L1_"),r=v(t,"L2_"),s="union_start",n=[s,...e.states,...r.states],i=[{from:s,to:e.start,input:""},{from:s,to:r.start,input:""},...e.transitions,...r.transitions];return{states:n,alphabet:et(e.alphabet,r.alphabet),transitions:i,start:s,accepts:[...e.accepts,...r.accepts]}}function Nt(o,t){let e=v(o,"C1_"),r=v(t,"C2_"),s=[];for(let n of e.accepts)s.push({from:n,to:r.start,input:""});return{states:[...e.states,...r.states],alphabet:et(e.alphabet,r.alphabet),transitions:[...e.transitions,...r.transitions,...s],start:e.start,accepts:[...r.accepts]}}function Et(o){let t=v(o,"K_"),e="star_hub",r=[{from:e,to:t.start,input:""}];for(let s of t.accepts)r.push({from:s,to:e,input:""}),r.push({from:s,to:t.start,input:""});return{states:[e,...t.states],alphabet:[...t.alphabet],transitions:[...t.transitions,...r],start:e,accepts:[e,...t.accepts]}}var Y={unionDefinitions:wt,concatDefinitions:Nt,kleeneStarDefinition:Et};function St(o,t){let e=new Map,r=[];for(let s of o)e.set(s.name,s),r.push(s);for(;r.length>0;){let s=r.pop();for(let n of t.getTFunc())n.origin===s&&n.input===""&&(e.has(n.dest.name)||(e.set(n.dest.name,n.dest),r.push(n.dest)))}return[...e.values()].sort((s,n)=>s.name.localeCompare(n.name))}function Dt(o,t,e){let r=new Map;for(let s of o)for(let n of e.getTFunc())n.origin===s&&n.input===t&&r.set(n.dest.name,n.dest);return[...r.values()].sort((s,n)=>s.name.localeCompare(n.name))}function nt(o){return o.map(t=>t.name).join(",")}function gt(o){if(!y(g,o))throw new TypeError("subsetConstruction requires an NFA");let t=B(o),e=new Set([...o.getAcceptStates()].map(m=>m.name)),r=St([o.getStartState()],o),s=new Map,n=new Map,i=[],a=m=>{let N=nt(m);if(!s.has(N)){let M=`d${s.size}`;s.set(N,M),n.set(M,m)}return s.get(N)},c=a(r),p=[r],l=new Set([nt(r)]),U=!1,d="dead";for(;p.length>0;){let m=p.pop(),N=a(m);for(let M of t){let rt=Dt(m,M,o),z=rt.length>0?St(rt,o):[],Z;if(z.length===0){if(!U){U=!0,n.set(d,[]);for(let W of t)i.push({from:d,to:d,input:W})}Z=d}else{let W=nt(z);Z=a(z),l.has(W)||(l.add(W),p.push(z))}i.push({from:N,to:Z,input:M})}}let X=[...n.keys()];U&&!X.includes(d)&&X.push(d);let mt=[...n.entries()].filter(([,m])=>m.some(N=>e.has(N.name))).map(([m])=>m);return{states:X,alphabet:t,transitions:i,start:c,accepts:mt}}var T,L=class L extends J{constructor(e){super();h(this,T);A(this,T,e)}getClassification(){return"regular"}static fromAutomaton(e){return new L(e)}contains(e){try{return!!j(e,u(this,T))}catch(r){if(r instanceof Error&&r.message===f.INVALID_INPUT_CHAR)return!1;throw r}}getAutomaton(){return u(this,T)}getAlphabetSymbols(){return B(u(this,T))}toDefinition(){return lt(u(this,T))}union(e){let r=Y.unionDefinitions(this.toDefinition(),e.toDefinition());return L.fromAutomaton(H(r))}concat(e){let r=Y.concatDefinitions(this.toDefinition(),e.toDefinition());return L.fromAutomaton(H(r))}kleeneStar(){let e=Y.kleeneStarDefinition(this.toDefinition());return L.fromAutomaton(H(e))}toDFA(){if(!y(g,u(this,T)))return this;let e=gt(u(this,T));return L.fromAutomaton(H(e))}};T=new WeakMap;var $=L;return bt(Ot);})();
+//# sourceMappingURL=demo-bundle.global.js.map

package/lib/index.cjs

@@ -0,0 +1,636 @@
+"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(_states2, _paths2, _tfunc2, _alph) {
+    const newTFunc = /* @__PURE__ */ new Set();
+    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 (!_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(_paths2, _t.origin, /* @__PURE__ */ new Set());
+      if (this.isValidInputChar(_t.input, _alph)) {
+        if (_paths2.has(_t.origin) && pathStateVals.has(_t.input)) {
+          newTFunc.add(_t);
+          pathStateVals.delete(_t.input);
+          if (pathStateVals.size === 0) {
+            _paths2.delete(_t.origin);
+          }
+        } else {
+          throw new Error(ErrorCode.DUPLICATE_TRANSITION_OBJECT);
+        }
+      } else {
+        throw new Error(ErrorCode.INVALID_INPUT_CHAR);
+      }
+    }
+    if (_paths2.size > 0) {
+      console.error("Not all FSA paths have a transition specified:");
+      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(_states2, _alph) {
+    const _paths2 = /* @__PURE__ */ new Map();
+    for (const state of _states2) {
+      for (const char of _alph.sigma) {
+        const pathStateVals = getOrDefault(_paths2, state, /* @__PURE__ */ new Set());
+        if (_paths2.has(state)) pathStateVals.add(char);
+        else _paths2.set(state, /* @__PURE__ */ new Set([char]));
+      }
+    }
+    return _paths2;
+  }
+  // Determine digraph order based on start state, then following the chain
+  static determineStateOrder(_links2, _tfunc2, _states2, _start2, _accepts2) {
+    const statesOrder = [];
+    _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, _start2.name, _links2);
+    const stateArr = [];
+    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, _states2, _accepts2, _tfunc2);
+    }
+    return statesOrder;
+  }
+  // Reduce FSA by removing dead states and associated transitions
+  static removeDeadStates(deadStates, _states2, _accepts2, _tfunc2) {
+    for (const state of _states2) {
+      if (deadStates.indexOf(state.name) !== -1) _states2.delete(state);
+    }
+    for (const state of _accepts2) {
+      if (deadStates.indexOf(state.name) !== -1) _accepts2.delete(state);
+    }
+    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, _links2) {
+    arr.push(name);
+    const nameVal = getOrDefault(_links2, name, /* @__PURE__ */ new Set());
+    for (const st of nameVal) {
+      if (arr.indexOf(st) === -1) this.parseLinks(arr, st, _links2);
+    }
+  }
+  // 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 _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);
+    _tfunc2.add(new Transition(fromVal, toVal, tr.input));
+  }
+  return new DFA(new Set(states.values()), alphabet, _tfunc2, 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(_tfunc2, state) {
+    let cont = true;
+    while (cont) {
+      cont = false;
+      const epsTransitions = Array.from(_tfunc2).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(_states2, _paths2, _tfunc2, _alph) {
+    const newTFunc = /* @__PURE__ */ new Set();
+    for (const _t of _tfunc2) {
+      let skip = false;
+      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 (!_states2.has(_t.dest)) {
+        console.error("Dest state was invalid: %o", JSON.stringify(_t.dest));
+        throw new Error(ErrorCode.DEST_STATE_NOT_FOUND);
+      }
+      for (const _checkT of newTFunc) {
+        if (_checkT.origin === _t.origin && _checkT.dest === _t.dest && _checkT.input === _t.input) skip = true;
+      }
+      if (!skip) {
+        if (_paths2.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 _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);
+    const fromVal = getOrDefault(states, tr.from, null);
+    const toVal = tr.to.split(",");
+    const destStates = [];
+    toVal.forEach((_dest) => {
+      destStates.push(getOrDefault(states, _dest, null));
+    });
+    _tfunc2.add(new NFATransition(fromVal, destStates, tr.input));
+  }
+  return new NFA(new Set(states.values()), alphabet, _tfunc2, 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);
+    }
+    const 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(_tfunc2, state) {
+    return NFAUtils.populateEpsilons(_tfunc2, 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(_states2, _paths2, _tfunc2, _alph) {
+      if (this._type === NFA) {
+        return NFAUtils.validateTFunc(_states2, _paths2, _tfunc2, _alph);
+      } else {
+        return DFAUtils.validateTFunc(_states2, _paths2, _tfunc2, _alph);
+      }
+    }
+    createPaths(_states2, _alph) {
+      return DFAUtils.createPaths(_states2, _alph);
+    }
+    determineStateOrder(_links2, _tfunc2, _states2, _start2, _accepts2) {
+      return DFAUtils.determineStateOrder(_links2, _tfunc2, _states2, _start2, _accepts2);
+    }
+  }
+  return FSAUtils2;
+})();
+var createFSA = (states, alphabet, transitions, start, accepts) => {
+  const _states2 = /* @__PURE__ */ new Map();
+  if (typeof states === "string") {
+    _states2.set(states, new State(states));
+  } else if (Array.isArray(states)) {
+    for (const state of states) {
+      if (!_states2.has(state)) _states2.set(state, new State(state));
+    }
+  } else {
+    throw new TypeError(String(states));
+  }
+  const _alphabet2 = new Alphabet(alphabet);
+  if (typeof start !== "string") throw new TypeError(String(start));
+  const _start2 = getOrDefault(_states2, start, null);
+  const _accepts2 = /* @__PURE__ */ new Set();
+  if (typeof accepts === "string") {
+    if (_states2.has(accepts)) _accepts2.add(getOrDefault(_states2, accepts, null));
+  } else if (Array.isArray(accepts)) {
+    for (const state of accepts) {
+      _accepts2.add(getOrDefault(_states2, 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(_states2, _alphabet2, transitionList, _start2, _accepts2);
+  }
+  return createDFA(_states2, _alphabet2, transitionList, _start2, _accepts2);
+};
+
+// src/automata/DFA.ts
+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	")}
+          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();
+
+// src/automata/NFA.ts
+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);
+  }
+  getType() {
+    return "NFA";
+  }
+};
+
+// 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