feat: Passwordless cross-device authentication

- Arkitektur: docs/auth/passwordless-architecture.md
- Backend: iom/quixzoom-auth-service/ (FastAPI + Redis)
- Webb: quixzoom-market-pages/se/login/ (QR-kod + polling)
- App: iom/quixzoom-app/src/features/auth/ (push + deep links)

Flöde: QR-kod → app-godkännande → webb-inloggad

landvex-admin-v2/node_modules/dfa/README.md

@@ -0,0 +1,83 @@
+# dfa
+
+Compiles a regular expression like syntax to fast deterministic finite automata.
+Useful for pattern matching against non-string sequences.
+
+## Example
+
+This example matches [Hangul](https://en.wikipedia.org/wiki/Hangul) syllables. The symbols defined in the machine are Unicode character categories which could be mapped from code points.
+
+Machine definition:
+
+```coffeescript
+# define symbols
+X   = 0; # Other character
+L   = 1; # Leading consonant
+V   = 2; # Medial vowel
+T   = 3; # Trailing consonant
+LV  = 4; # Composed <LV> syllable
+LVT = 5; # Composed <LVT> syllable
+M   = 6; # Tone mark
+
+# define variables
+decomposed = L V T?;
+partial = LV T?;
+composed = LVT;
+
+# define main state machine pattern
+main = (decomposed | partial | composed) M?;
+```
+
+Visualized, the machine looks like this (double circles are accepting states):
+
+![dfa](https://cloud.githubusercontent.com/assets/19409/19143719/8fbc6a12-8b5a-11e6-868d-99621644d094.png)
+
+Compiling and using the machine:
+
+```javascript
+import compile from 'dfa/compile';
+import fs from 'fs';
+
+let stateMachine = compile(fs.readFileSync('hangul.machine', 'utf8'));
+
+// find matches
+for (let [startIndex, endIndex] of stateMachine.match([0, 1, 2, 3, 0, 4, 6]) {
+  console.log('match:', startIndex, endIndex);
+}
+```
+
+Output:
+```
+match: 1 3
+match: 5 6
+```
+
+## Syntax
+
+A state machine file contains a list of assignment statements. Comments are also allowed
+and are started with the `#` character. Each statement is an assignment of a variable name
+to a value or expression. Assigning a variable to a number produces a symbol, which is
+added to the state machine's alphabet. Assigning a variable to an expression allows
+for substitutions into later expressions. The special `main` variable should always be
+assigned to at the end of the file, and is the final expression that will be compiled.
+
+A subset of common regular expression syntax is supported. A list of operators and their
+precedence is below. Operators with the same precedence are evaluated left to right.
+
+| Precedence | Syntax     | Type          | Meaning                                    |
+| ---------- | ---------- | --------------| ------------------------------------------ |
+| 1          | `a \| b`   | Alternation   | Matches either `a` or `b`                  |
+| 2          | `a b`      | Concatenation | Matches `a` followed by `b`                |
+| 3          | `a*`       | Repetition    | Matches zero or more occurrences of `a`    |
+| 3          | `a+`       | Repetition    | Matches one ore more occurrences of `a`    |
+| 3          | `a?`       | Optional      | Matches zero or one occurrence of `a`      |
+| 3          | `a{n}`     | Repetition    | Matches exactly n occurrences of `a`       |
+| 3          | `a{n,}`    | Repetition    | Matches n or more occurrences of `a`       |
+| 3          | `a{,n}`    | Repetition    | Matches up to n occurrences of `a`         |
+| 3          | `a{n,m}`   | Repetition    | Matches n to m occurrences of `a`          |
+| 4          | `t:<expr>` | Tag           | Tags the following expression with tag `t` |
+| 5          | `(<expr>)` | Grouping      | Groups an expression                       |
+
+## License
+
+MIT

landvex-admin-v2/node_modules/dfa/compile.js

@@ -0,0 +1,1834 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * Returns a new set representing the union of a and b.
+ */
+function union(a, b) {
+  var s = new Set(a);
+  addAll(s, b);
+  return s;
+}
+/**
+ * Adds all items from the set b to a.
+ */
+
+function addAll(a, b) {
+  for (var x of b) {
+    a.add(x);
+  }
+}
+/**
+ * Returns whether two sets are equal
+ */
+
+function equal(a, b) {
+  if (a === b) return true;
+  if (a.size !== b.size) return false;
+
+  for (var x of a) {
+    if (!b.has(x)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Base AST node
+ */
+
+class Node {
+  constructor() {
+    Object.defineProperty(this, 'followpos', {
+      value: new Set()
+    });
+  }
+
+  calcFollowpos() {
+    for (var key in this) {
+      if (this[key] instanceof Node) {
+        this[key].calcFollowpos();
+      }
+    }
+  }
+
+}
+/**
+ * Represents a variable reference
+ */
+
+class Variable extends Node {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+
+  copy() {
+    return new Variable(this.name);
+  }
+
+}
+/**
+ * Represents a comment
+ */
+
+class Comment extends Node {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+
+}
+/**
+ * Represents an assignment statement.
+ * e.g. `variable = expression;`
+ */
+
+class Assignment extends Node {
+  constructor(variable, expression) {
+    super();
+    this.variable = variable;
+    this.expression = expression;
+  }
+
+}
+/**
+ * Represents an alternation.
+ * e.g. `a | b`
+ */
+
+class Alternation extends Node {
+  constructor(a, b) {
+    super();
+    this.a = a;
+    this.b = b;
+  }
+
+  get nullable() {
+    return this.a.nullable || this.b.nullable;
+  }
+
+  get firstpos() {
+    return union(this.a.firstpos, this.b.firstpos);
+  }
+
+  get lastpos() {
+    return union(this.a.lastpos, this.b.lastpos);
+  }
+
+  copy() {
+    return new Alternation(this.a.copy(), this.b.copy());
+  }
+
+}
+/**
+ * Represents a concatenation, or chain.
+ * e.g. `a b c`
+ */
+
+class Concatenation extends Node {
+  constructor(a, b) {
+    super();
+    this.a = a;
+    this.b = b;
+  }
+
+  get nullable() {
+    return this.a.nullable && this.b.nullable;
+  }
+
+  get firstpos() {
+    var s = this.a.firstpos;
+
+    if (this.a.nullable) {
+      s = union(s, this.b.firstpos);
+    }
+
+    return s;
+  }
+
+  get lastpos() {
+    var s = this.b.lastpos;
+
+    if (this.b.nullable) {
+      s = union(s, this.a.lastpos);
+    }
+
+    return s;
+  }
+
+  calcFollowpos() {
+    super.calcFollowpos();
+
+    for (var n of this.a.lastpos) {
+      addAll(n.followpos, this.b.firstpos);
+    }
+  }
+
+  copy() {
+    return new Concatenation(this.a.copy(), this.b.copy());
+  }
+
+}
+/**
+ * Represents a repetition.
+ * e.g. `a+`, `b*`, or `c?`
+ */
+
+class Repeat extends Node {
+  constructor(expression, op) {
+    super();
+    this.expression = expression;
+    this.op = op;
+  }
+
+  get nullable() {
+    return this.op === '*' || this.op === '?';
+  }
+
+  get firstpos() {
+    return this.expression.firstpos;
+  }
+
+  get lastpos() {
+    return this.expression.lastpos;
+  }
+
+  calcFollowpos() {
+    super.calcFollowpos();
+
+    if (this.op === '*' || this.op === '+') {
+      for (var n of this.lastpos) {
+        addAll(n.followpos, this.firstpos);
+      }
+    }
+  }
+
+  copy() {
+    return new Repeat(this.expression.copy(), this.op);
+  }
+
+}
+function buildRepetition(expression, min = 0, max = Infinity) {
+  if (min < 0 || min > max) {
+    throw new Error("Invalid repetition range: ".concat(min, " ").concat(max));
+  }
+
+  var res = null;
+
+  for (var i = 0; i < min; i++) {
+    res = concat(res, expression.copy());
+  }
+
+  if (max === Infinity) {
+    res = concat(res, new Repeat(expression.copy(), '*'));
+  } else {
+    for (var _i = min; _i < max; _i++) {
+      res = concat(res, new Repeat(expression.copy(), '?'));
+    }
+  }
+
+  return res;
+}
+
+function concat(a, b) {
+  if (!a) {
+    return b;
+  }
+
+  return new Concatenation(a, b);
+}
+/**
+ * Base class for leaf nodes
+ */
+
+
+class Leaf extends Node {
+  get nullable() {
+    return false;
+  }
+
+  get firstpos() {
+    return new Set([this]);
+  }
+
+  get lastpos() {
+    return new Set([this]);
+  }
+
+}
+/**
+ * Represents a literal value, e.g. a number
+ */
+
+
+class Literal extends Leaf {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+
+  copy() {
+    return new Literal(this.value);
+  }
+
+}
+/**
+ * Marks the end of an expression
+ */
+
+class EndMarker extends Leaf {}
+/**
+ * Represents a tag
+ * e.g. `a:(a b)`
+ */
+
+class Tag extends Leaf {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+
+  get nullable() {
+    return true;
+  }
+
+  copy() {
+    return new Tag(this.name);
+  }
+
+}
+
+var nodes = /*#__PURE__*/Object.freeze({
+  Node: Node,
+  Variable: Variable,
+  Comment: Comment,
+  Assignment: Assignment,
+  Alternation: Alternation,
+  Concatenation: Concatenation,
+  Repeat: Repeat,
+  buildRepetition: buildRepetition,
+  Literal: Literal,
+  EndMarker: EndMarker,
+  Tag: Tag
+});
+
+function peg$subclass(child, parent) {
+  function ctor() {
+    this.constructor = child;
+  }
+
+  ctor.prototype = parent.prototype;
+  child.prototype = new ctor();
+}
+
+function peg$SyntaxError(message, expected, found, location) {
+  this.message = message;
+  this.expected = expected;
+  this.found = found;
+  this.location = location;
+  this.name = "SyntaxError";
+
+  if (typeof Error.captureStackTrace === "function") {
+    Error.captureStackTrace(this, peg$SyntaxError);
+  }
+}
+
+peg$subclass(peg$SyntaxError, Error);
+
+peg$SyntaxError.buildMessage = function (expected, found) {
+  var DESCRIBE_EXPECTATION_FNS = {
+    literal: function (expectation) {
+      return "\"" + literalEscape(expectation.text) + "\"";
+    },
+    "class": function (expectation) {
+      var escapedParts = "",
+          i;
+
+      for (i = 0; i < expectation.parts.length; i++) {
+        escapedParts += expectation.parts[i] instanceof Array ? classEscape(expectation.parts[i][0]) + "-" + classEscape(expectation.parts[i][1]) : classEscape(expectation.parts[i]);
+      }
+
+      return "[" + (expectation.inverted ? "^" : "") + escapedParts + "]";
+    },
+    any: function (expectation) {
+      return "any character";
+    },
+    end: function (expectation) {
+      return "end of input";
+    },
+    other: function (expectation) {
+      return expectation.description;
+    }
+  };
+
+  function hex(ch) {
+    return ch.charCodeAt(0).toString(16).toUpperCase();
+  }
+
+  function literalEscape(s) {
+    return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\0/g, '\\0').replace(/\t/g, '\\t').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/[\x00-\x0F]/g, function (ch) {
+      return '\\x0' + hex(ch);
+    }).replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
+      return '\\x' + hex(ch);
+    });
+  }
+
+  function classEscape(s) {
+    return s.replace(/\\/g, '\\\\').replace(/\]/g, '\\]').replace(/\^/g, '\\^').replace(/-/g, '\\-').replace(/\0/g, '\\0').replace(/\t/g, '\\t').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/[\x00-\x0F]/g, function (ch) {
+      return '\\x0' + hex(ch);
+    }).replace(/[\x10-\x1F\x7F-\x9F]/g, function (ch) {
+      return '\\x' + hex(ch);
+    });
+  }
+
+  function describeExpectation(expectation) {
+    return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);
+  }
+
+  function describeExpected(expected) {
+    var descriptions = new Array(expected.length),
+        i,
+        j;
+
+    for (i = 0; i < expected.length; i++) {
+      descriptions[i] = describeExpectation(expected[i]);
+    }
+
+    descriptions.sort();
+
+    if (descriptions.length > 0) {
+      for (i = 1, j = 1; i < descriptions.length; i++) {
+        if (descriptions[i - 1] !== descriptions[i]) {
+          descriptions[j] = descriptions[i];
+          j++;
+        }
+      }
+
+      descriptions.length = j;
+    }
+
+    switch (descriptions.length) {
+      case 1:
+        return descriptions[0];
+
+      case 2:
+        return descriptions[0] + " or " + descriptions[1];
+
+      default:
+        return descriptions.slice(0, -1).join(", ") + ", or " + descriptions[descriptions.length - 1];
+    }
+  }
+
+  function describeFound(found) {
+    return found ? "\"" + literalEscape(found) + "\"" : "end of input";
+  }
+
+  return "Expected " + describeExpected(expected) + " but " + describeFound(found) + " found.";
+};
+
+function peg$parse(input, options) {
+  options = options !== void 0 ? options : {};
+
+  var peg$FAILED = {},
+      peg$startRuleFunctions = {
+    rules: peg$parserules
+  },
+      peg$startRuleFunction = peg$parserules,
+      peg$c0 = function (s) {
+    return s;
+  },
+      peg$c1 = "#",
+      peg$c2 = peg$literalExpectation("#", false),
+      peg$c3 = /^[^\r\n]/,
+      peg$c4 = peg$classExpectation(["\r", "\n"], true, false),
+      peg$c5 = /^[\r\n]/,
+      peg$c6 = peg$classExpectation(["\r", "\n"], false, false),
+      peg$c7 = function (v) {
+    return new n.Comment(v.join(''));
+  },
+      peg$c8 = "=",
+      peg$c9 = peg$literalExpectation("=", false),
+      peg$c10 = ";",
+      peg$c11 = peg$literalExpectation(";", false),
+      peg$c12 = function (v, e) {
+    return new n.Assignment(v, e);
+  },
+      peg$c13 = function (v) {
+    return new n.Variable(v);
+  },
+      peg$c14 = "|",
+      peg$c15 = peg$literalExpectation("|", false),
+      peg$c16 = function (a, b) {
+    return new n.Alternation(a, b);
+  },
+      peg$c17 = function (a, b) {
+    return new n.Concatenation(a, b);
+  },
+      peg$c18 = ":",
+      peg$c19 = peg$literalExpectation(":", false),
+      peg$c20 = function (t, e) {
+    return new n.Concatenation(e, new n.Tag(t));
+  },
+      peg$c21 = "*",
+      peg$c22 = peg$literalExpectation("*", false),
+      peg$c23 = function (t) {
+    return new n.Repeat(t, '*');
+  },
+      peg$c24 = "?",
+      peg$c25 = peg$literalExpectation("?", false),
+      peg$c26 = function (t) {
+    return new n.Repeat(t, '?');
+  },
+      peg$c27 = "+",
+      peg$c28 = peg$literalExpectation("+", false),
+      peg$c29 = function (t) {
+    return new n.Repeat(t, '+');
+  },
+      peg$c30 = "{",
+      peg$c31 = peg$literalExpectation("{", false),
+      peg$c32 = "}",
+      peg$c33 = peg$literalExpectation("}", false),
+      peg$c34 = function (t, m) {
+    return n.buildRepetition(t, m, m);
+  },
+      peg$c35 = ",",
+      peg$c36 = peg$literalExpectation(",", false),
+      peg$c37 = function (t, min) {
+    return n.buildRepetition(t, min, Infinity);
+  },
+      peg$c38 = function (t, max) {
+    return n.buildRepetition(t, 0, max);
+  },
+      peg$c39 = function (t, min, max) {
+    return n.buildRepetition(t, min, max);
+  },
+      peg$c40 = function (x) {
+    return new n.Literal(x);
+  },
+      peg$c41 = "(",
+      peg$c42 = peg$literalExpectation("(", false),
+      peg$c43 = ")",
+      peg$c44 = peg$literalExpectation(")", false),
+      peg$c45 = function (e) {
+    return e;
+  },
+      peg$c47 = function (a, b) {
+    return a + b.join('');
+  },
+      peg$c48 = "_",
+      peg$c49 = peg$literalExpectation("_", false),
+      peg$c50 = /^[a-zA-Z]/,
+      peg$c51 = peg$classExpectation([["a", "z"], ["A", "Z"]], false, false),
+      peg$c52 = /^[0-9]/,
+      peg$c53 = peg$classExpectation([["0", "9"]], false, false),
+      peg$c54 = function (num) {
+    return parseInt(num.join(''));
+  },
+      peg$c55 = /^[ \t\r\n]/,
+      peg$c56 = peg$classExpectation([" ", "\t", "\r", "\n"], false, false),
+      peg$currPos = 0,
+      peg$posDetailsCache = [{
+    line: 1,
+    column: 1
+  }],
+      peg$maxFailPos = 0,
+      peg$maxFailExpected = [],
+      peg$result;
+
+  if ("startRule" in options) {
+    if (!(options.startRule in peg$startRuleFunctions)) {
+      throw new Error("Can't start parsing from rule \"" + options.startRule + "\".");
+    }
+
+    peg$startRuleFunction = peg$startRuleFunctions[options.startRule];
+  }
+
+  function peg$literalExpectation(text, ignoreCase) {
+    return {
+      type: "literal",
+      text: text,
+      ignoreCase: ignoreCase
+    };
+  }
+
+  function peg$classExpectation(parts, inverted, ignoreCase) {
+    return {
+      type: "class",
+      parts: parts,
+      inverted: inverted,
+      ignoreCase: ignoreCase
+    };
+  }
+
+  function peg$endExpectation() {
+    return {
+      type: "end"
+    };
+  }
+
+  function peg$computePosDetails(pos) {
+    var details = peg$posDetailsCache[pos],
+        p;
+
+    if (details) {
+      return details;
+    } else {
+      p = pos - 1;
+
+      while (!peg$posDetailsCache[p]) {
+        p--;
+      }
+
+      details = peg$posDetailsCache[p];
+      details = {
+        line: details.line,
+        column: details.column
+      };
+
+      while (p < pos) {
+        if (input.charCodeAt(p) === 10) {
+          details.line++;
+          details.column = 1;
+        } else {
+          details.column++;
+        }
+
+        p++;
+      }
+
+      peg$posDetailsCache[pos] = details;
+      return details;
+    }
+  }
+
+  function peg$computeLocation(startPos, endPos) {
+    var startPosDetails = peg$computePosDetails(startPos),
+        endPosDetails = peg$computePosDetails(endPos);
+    return {
+      start: {
+        offset: startPos,
+        line: startPosDetails.line,
+        column: startPosDetails.column
+      },
+      end: {
+        offset: endPos,
+        line: endPosDetails.line,
+        column: endPosDetails.column
+      }
+    };
+  }
+
+  function peg$fail(expected) {
+    if (peg$currPos < peg$maxFailPos) {
+      return;
+    }
+
+    if (peg$currPos > peg$maxFailPos) {
+      peg$maxFailPos = peg$currPos;
+      peg$maxFailExpected = [];
+    }
+
+    peg$maxFailExpected.push(expected);
+  }
+
+  function peg$buildStructuredError(expected, found, location) {
+    return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);
+  }
+
+  function peg$parserules() {
+    var s0, s1;
+    s0 = [];
+    s1 = peg$parsestatement();
+
+    if (s1 !== peg$FAILED) {
+      while (s1 !== peg$FAILED) {
+        s0.push(s1);
+        s1 = peg$parsestatement();
+      }
+    } else {
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsestatement() {
+    var s0, s1, s2;
+    s0 = peg$currPos;
+    s1 = peg$parsestatement_type();
+
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parse_();
+
+      if (s2 !== peg$FAILED) {
+        s1 = peg$c0(s1);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsestatement_type() {
+    var s0;
+    s0 = peg$parseassignment();
+
+    if (s0 === peg$FAILED) {
+      s0 = peg$parsecomment();
+    }
+
+    return s0;
+  }
+
+  function peg$parsecomment() {
+    var s0, s1, s2, s3;
+    s0 = peg$currPos;
+
+    if (input.charCodeAt(peg$currPos) === 35) {
+      s1 = peg$c1;
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+
+      {
+        peg$fail(peg$c2);
+      }
+    }
+
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+
+      if (peg$c3.test(input.charAt(peg$currPos))) {
+        s3 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s3 = peg$FAILED;
+
+        {
+          peg$fail(peg$c4);
+        }
+      }
+
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+
+        if (peg$c3.test(input.charAt(peg$currPos))) {
+          s3 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+
+          {
+            peg$fail(peg$c4);
+          }
+        }
+      }
+
+      if (s2 !== peg$FAILED) {
+        if (peg$c5.test(input.charAt(peg$currPos))) {
+          s3 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+
+          {
+            peg$fail(peg$c6);
+          }
+        }
+
+        if (s3 !== peg$FAILED) {
+          s1 = peg$c7(s2);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parseassignment() {
+    var s0, s1, s2, s3, s4, s5, s6, s7;
+    s0 = peg$currPos;
+    s1 = peg$parsevariable();
+
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parse_();
+
+      if (s2 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 61) {
+          s3 = peg$c8;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+
+          {
+            peg$fail(peg$c9);
+          }
+        }
+
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parse_();
+
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parsealternation();
+
+            if (s5 !== peg$FAILED) {
+              s6 = peg$parse_();
+
+              if (s6 !== peg$FAILED) {
+                if (input.charCodeAt(peg$currPos) === 59) {
+                  s7 = peg$c10;
+                  peg$currPos++;
+                } else {
+                  s7 = peg$FAILED;
+
+                  {
+                    peg$fail(peg$c11);
+                  }
+                }
+
+                if (s7 !== peg$FAILED) {
+                  s1 = peg$c12(s1, s5);
+                  s0 = s1;
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsevariable() {
+    var s0, s1;
+    s0 = peg$currPos;
+    s1 = peg$parsename();
+
+    if (s1 !== peg$FAILED) {
+      s1 = peg$c13(s1);
+    }
+
+    s0 = s1;
+    return s0;
+  }
+
+  function peg$parsealternation() {
+    var s0, s1, s2, s3, s4, s5;
+    s0 = peg$currPos;
+    s1 = peg$parseconcatenation();
+
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parse_();
+
+      if (s2 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 124) {
+          s3 = peg$c14;
+          peg$currPos++;
+        } else {
+          s3 = peg$FAILED;
+
+          {
+            peg$fail(peg$c15);
+          }
+        }
+
+        if (s3 !== peg$FAILED) {
+          s4 = peg$parse_();
+
+          if (s4 !== peg$FAILED) {
+            s5 = peg$parsealternation();
+
+            if (s5 !== peg$FAILED) {
+              s1 = peg$c16(s1, s5);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    if (s0 === peg$FAILED) {
+      s0 = peg$parseconcatenation();
+    }
+
+    return s0;
+  }
+
+  function peg$parseconcatenation() {
+    var s0, s1, s2, s3;
+    s0 = peg$currPos;
+    s1 = peg$parserepeat();
+
+    if (s1 !== peg$FAILED) {
+      s2 = peg$parse_();
+
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parseconcatenation();
+
+        if (s3 !== peg$FAILED) {
+          s1 = peg$c17(s1, s3);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    if (s0 === peg$FAILED) {
+      s0 = peg$parserepeat();
+    }
+
+    return s0;
+  }
+
+  function peg$parserepeat() {
+    var s0, s1, s2, s3, s4, s5, s6;
+    s0 = peg$currPos;
+    s1 = peg$parsename();
+
+    if (s1 !== peg$FAILED) {
+      if (input.charCodeAt(peg$currPos) === 58) {
+        s2 = peg$c18;
+        peg$currPos++;
+      } else {
+        s2 = peg$FAILED;
+
+        {
+          peg$fail(peg$c19);
+        }
+      }
+
+      if (s2 !== peg$FAILED) {
+        s3 = peg$parserepeat();
+
+        if (s3 !== peg$FAILED) {
+          s1 = peg$c20(s1, s3);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parseterm();
+
+      if (s1 !== peg$FAILED) {
+        if (input.charCodeAt(peg$currPos) === 42) {
+          s2 = peg$c21;
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+
+          {
+            peg$fail(peg$c22);
+          }
+        }
+
+        if (s2 !== peg$FAILED) {
+          s1 = peg$c23(s1);
+          s0 = s1;
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+        s1 = peg$parseterm();
+
+        if (s1 !== peg$FAILED) {
+          if (input.charCodeAt(peg$currPos) === 63) {
+            s2 = peg$c24;
+            peg$currPos++;
+          } else {
+            s2 = peg$FAILED;
+
+            {
+              peg$fail(peg$c25);
+            }
+          }
+
+          if (s2 !== peg$FAILED) {
+            s1 = peg$c26(s1);
+            s0 = s1;
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+
+        if (s0 === peg$FAILED) {
+          s0 = peg$currPos;
+          s1 = peg$parseterm();
+
+          if (s1 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 43) {
+              s2 = peg$c27;
+              peg$currPos++;
+            } else {
+              s2 = peg$FAILED;
+
+              {
+                peg$fail(peg$c28);
+              }
+            }
+
+            if (s2 !== peg$FAILED) {
+              s1 = peg$c29(s1);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+
+          if (s0 === peg$FAILED) {
+            s0 = peg$currPos;
+            s1 = peg$parseterm();
+
+            if (s1 !== peg$FAILED) {
+              if (input.charCodeAt(peg$currPos) === 123) {
+                s2 = peg$c30;
+                peg$currPos++;
+              } else {
+                s2 = peg$FAILED;
+
+                {
+                  peg$fail(peg$c31);
+                }
+              }
+
+              if (s2 !== peg$FAILED) {
+                s3 = peg$parsenumber();
+
+                if (s3 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 125) {
+                    s4 = peg$c32;
+                    peg$currPos++;
+                  } else {
+                    s4 = peg$FAILED;
+
+                    {
+                      peg$fail(peg$c33);
+                    }
+                  }
+
+                  if (s4 !== peg$FAILED) {
+                    s1 = peg$c34(s1, s3);
+                    s0 = s1;
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+
+            if (s0 === peg$FAILED) {
+              s0 = peg$currPos;
+              s1 = peg$parseterm();
+
+              if (s1 !== peg$FAILED) {
+                if (input.charCodeAt(peg$currPos) === 123) {
+                  s2 = peg$c30;
+                  peg$currPos++;
+                } else {
+                  s2 = peg$FAILED;
+
+                  {
+                    peg$fail(peg$c31);
+                  }
+                }
+
+                if (s2 !== peg$FAILED) {
+                  s3 = peg$parsenumber();
+
+                  if (s3 !== peg$FAILED) {
+                    if (input.charCodeAt(peg$currPos) === 44) {
+                      s4 = peg$c35;
+                      peg$currPos++;
+                    } else {
+                      s4 = peg$FAILED;
+
+                      {
+                        peg$fail(peg$c36);
+                      }
+                    }
+
+                    if (s4 !== peg$FAILED) {
+                      if (input.charCodeAt(peg$currPos) === 125) {
+                        s5 = peg$c32;
+                        peg$currPos++;
+                      } else {
+                        s5 = peg$FAILED;
+
+                        {
+                          peg$fail(peg$c33);
+                        }
+                      }
+
+                      if (s5 !== peg$FAILED) {
+                        s1 = peg$c37(s1, s3);
+                        s0 = s1;
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+              } else {
+                peg$currPos = s0;
+                s0 = peg$FAILED;
+              }
+
+              if (s0 === peg$FAILED) {
+                s0 = peg$currPos;
+                s1 = peg$parseterm();
+
+                if (s1 !== peg$FAILED) {
+                  if (input.charCodeAt(peg$currPos) === 123) {
+                    s2 = peg$c30;
+                    peg$currPos++;
+                  } else {
+                    s2 = peg$FAILED;
+
+                    {
+                      peg$fail(peg$c31);
+                    }
+                  }
+
+                  if (s2 !== peg$FAILED) {
+                    if (input.charCodeAt(peg$currPos) === 44) {
+                      s3 = peg$c35;
+                      peg$currPos++;
+                    } else {
+                      s3 = peg$FAILED;
+
+                      {
+                        peg$fail(peg$c36);
+                      }
+                    }
+
+                    if (s3 !== peg$FAILED) {
+                      s4 = peg$parsenumber();
+
+                      if (s4 !== peg$FAILED) {
+                        if (input.charCodeAt(peg$currPos) === 125) {
+                          s5 = peg$c32;
+                          peg$currPos++;
+                        } else {
+                          s5 = peg$FAILED;
+
+                          {
+                            peg$fail(peg$c33);
+                          }
+                        }
+
+                        if (s5 !== peg$FAILED) {
+                          s1 = peg$c38(s1, s4);
+                          s0 = s1;
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+                } else {
+                  peg$currPos = s0;
+                  s0 = peg$FAILED;
+                }
+
+                if (s0 === peg$FAILED) {
+                  s0 = peg$currPos;
+                  s1 = peg$parseterm();
+
+                  if (s1 !== peg$FAILED) {
+                    if (input.charCodeAt(peg$currPos) === 123) {
+                      s2 = peg$c30;
+                      peg$currPos++;
+                    } else {
+                      s2 = peg$FAILED;
+
+                      {
+                        peg$fail(peg$c31);
+                      }
+                    }
+
+                    if (s2 !== peg$FAILED) {
+                      s3 = peg$parsenumber();
+
+                      if (s3 !== peg$FAILED) {
+                        if (input.charCodeAt(peg$currPos) === 44) {
+                          s4 = peg$c35;
+                          peg$currPos++;
+                        } else {
+                          s4 = peg$FAILED;
+
+                          {
+                            peg$fail(peg$c36);
+                          }
+                        }
+
+                        if (s4 !== peg$FAILED) {
+                          s5 = peg$parsenumber();
+
+                          if (s5 !== peg$FAILED) {
+                            if (input.charCodeAt(peg$currPos) === 125) {
+                              s6 = peg$c32;
+                              peg$currPos++;
+                            } else {
+                              s6 = peg$FAILED;
+
+                              {
+                                peg$fail(peg$c33);
+                              }
+                            }
+
+                            if (s6 !== peg$FAILED) {
+                              s1 = peg$c39(s1, s3, s5);
+                              s0 = s1;
+                            } else {
+                              peg$currPos = s0;
+                              s0 = peg$FAILED;
+                            }
+                          } else {
+                            peg$currPos = s0;
+                            s0 = peg$FAILED;
+                          }
+                        } else {
+                          peg$currPos = s0;
+                          s0 = peg$FAILED;
+                        }
+                      } else {
+                        peg$currPos = s0;
+                        s0 = peg$FAILED;
+                      }
+                    } else {
+                      peg$currPos = s0;
+                      s0 = peg$FAILED;
+                    }
+                  } else {
+                    peg$currPos = s0;
+                    s0 = peg$FAILED;
+                  }
+
+                  if (s0 === peg$FAILED) {
+                    s0 = peg$parseterm();
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parseterm() {
+    var s0, s1, s2, s3;
+    s0 = peg$parsevariable();
+
+    if (s0 === peg$FAILED) {
+      s0 = peg$currPos;
+      s1 = peg$parsenumber();
+
+      if (s1 !== peg$FAILED) {
+        s1 = peg$c40(s1);
+      }
+
+      s0 = s1;
+
+      if (s0 === peg$FAILED) {
+        s0 = peg$currPos;
+
+        if (input.charCodeAt(peg$currPos) === 40) {
+          s1 = peg$c41;
+          peg$currPos++;
+        } else {
+          s1 = peg$FAILED;
+
+          {
+            peg$fail(peg$c42);
+          }
+        }
+
+        if (s1 !== peg$FAILED) {
+          s2 = peg$parsealternation();
+
+          if (s2 !== peg$FAILED) {
+            if (input.charCodeAt(peg$currPos) === 41) {
+              s3 = peg$c43;
+              peg$currPos++;
+            } else {
+              s3 = peg$FAILED;
+
+              {
+                peg$fail(peg$c44);
+              }
+            }
+
+            if (s3 !== peg$FAILED) {
+              s1 = peg$c45(s2);
+              s0 = s1;
+            } else {
+              peg$currPos = s0;
+              s0 = peg$FAILED;
+            }
+          } else {
+            peg$currPos = s0;
+            s0 = peg$FAILED;
+          }
+        } else {
+          peg$currPos = s0;
+          s0 = peg$FAILED;
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parsename() {
+    var s0, s1, s2, s3;
+    s0 = peg$currPos;
+    s1 = peg$parsename_start_char();
+
+    if (s1 !== peg$FAILED) {
+      s2 = [];
+      s3 = peg$parsename_char();
+
+      while (s3 !== peg$FAILED) {
+        s2.push(s3);
+        s3 = peg$parsename_char();
+      }
+
+      if (s2 !== peg$FAILED) {
+        s1 = peg$c47(s1, s2);
+        s0 = s1;
+      } else {
+        peg$currPos = s0;
+        s0 = peg$FAILED;
+      }
+    } else {
+      peg$currPos = s0;
+      s0 = peg$FAILED;
+    }
+
+    return s0;
+  }
+
+  function peg$parsename_start_char() {
+    var s0;
+
+    if (input.charCodeAt(peg$currPos) === 95) {
+      s0 = peg$c48;
+      peg$currPos++;
+    } else {
+      s0 = peg$FAILED;
+
+      {
+        peg$fail(peg$c49);
+      }
+    }
+
+    if (s0 === peg$FAILED) {
+      if (peg$c50.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+
+        {
+          peg$fail(peg$c51);
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parsename_char() {
+    var s0;
+    s0 = peg$parsename_start_char();
+
+    if (s0 === peg$FAILED) {
+      if (peg$c52.test(input.charAt(peg$currPos))) {
+        s0 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s0 = peg$FAILED;
+
+        {
+          peg$fail(peg$c53);
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  function peg$parsenumber() {
+    var s0, s1, s2;
+    s0 = peg$currPos;
+    s1 = [];
+
+    if (peg$c52.test(input.charAt(peg$currPos))) {
+      s2 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s2 = peg$FAILED;
+
+      {
+        peg$fail(peg$c53);
+      }
+    }
+
+    if (s2 !== peg$FAILED) {
+      while (s2 !== peg$FAILED) {
+        s1.push(s2);
+
+        if (peg$c52.test(input.charAt(peg$currPos))) {
+          s2 = input.charAt(peg$currPos);
+          peg$currPos++;
+        } else {
+          s2 = peg$FAILED;
+
+          {
+            peg$fail(peg$c53);
+          }
+        }
+      }
+    } else {
+      s1 = peg$FAILED;
+    }
+
+    if (s1 !== peg$FAILED) {
+      s1 = peg$c54(s1);
+    }
+
+    s0 = s1;
+    return s0;
+  }
+
+  function peg$parse_() {
+    var s0, s1;
+    s0 = [];
+
+    if (peg$c55.test(input.charAt(peg$currPos))) {
+      s1 = input.charAt(peg$currPos);
+      peg$currPos++;
+    } else {
+      s1 = peg$FAILED;
+
+      {
+        peg$fail(peg$c56);
+      }
+    }
+
+    while (s1 !== peg$FAILED) {
+      s0.push(s1);
+
+      if (peg$c55.test(input.charAt(peg$currPos))) {
+        s1 = input.charAt(peg$currPos);
+        peg$currPos++;
+      } else {
+        s1 = peg$FAILED;
+
+        {
+          peg$fail(peg$c56);
+        }
+      }
+    }
+
+    return s0;
+  }
+
+  var n = nodes;
+  peg$result = peg$startRuleFunction();
+
+  if (peg$result !== peg$FAILED && peg$currPos === input.length) {
+    return peg$result;
+  } else {
+    if (peg$result !== peg$FAILED && peg$currPos < input.length) {
+      peg$fail(peg$endExpectation());
+    }
+
+    throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1) : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));
+  }
+}
+
+var grammar = {
+  SyntaxError: peg$SyntaxError,
+  parse: peg$parse
+};
+
+/**
+ * Processes a list of statements into a symbol table
+ */
+
+class SymbolTable {
+  constructor(statements, externalSymbols = {}) {
+    this.variables = {};
+    this.symbols = {};
+    this.main = null;
+    this.size = 0;
+    this.addExternalSymbols(externalSymbols);
+    this.process(statements);
+  }
+
+  addExternalSymbols(externalSymbols) {
+    for (var key in externalSymbols) {
+      this.variables[key] = new Literal(externalSymbols[key]);
+      this.symbols[key] = externalSymbols[key];
+      this.size++;
+    }
+  }
+
+  process(statements) {
+    for (var statement of statements) {
+      if (statement instanceof Assignment) {
+        this.variables[statement.variable.name] = this.processExpression(statement.expression);
+
+        if (statement.expression instanceof Literal) {
+          this.symbols[statement.variable.name] = statement.expression.value;
+          this.size++;
+        }
+      }
+    }
+
+    this.main = this.variables.main;
+
+    if (!this.main) {
+      throw new Error('No main variable declaration found');
+    }
+  }
+
+  processExpression(expr) {
+    // Process children
+    for (var key in expr) {
+      if (expr[key] instanceof Node) {
+        expr[key] = this.processExpression(expr[key]);
+      }
+    } // Replace variable references with their values
+
+
+    if (expr instanceof Variable) {
+      var value = this.variables[expr.name];
+      if (value == null) throw new Error("Undeclared indentifier ".concat(expr.name));
+      expr = this.processExpression(value.copy());
+    }
+
+    return expr;
+  }
+
+}
+
+var END_MARKER = new EndMarker();
+/**
+ * This is an implementation of the direct regular expression to DFA algorithm described
+ * in section 3.9.5 of "Compilers: Principles, Techniques, and Tools" by Aho,
+ * Lam, Sethi, and Ullman. http://dragonbook.stanford.edu
+ * There is a PDF of the book here:
+ * http://www.informatik.uni-bremen.de/agbkb/lehre/ccfl/Material/ALSUdragonbook.pdf
+ */
+
+function buildDFA(root, numSymbols) {
+  root = new Concatenation(root, END_MARKER);
+  root.calcFollowpos();
+  var failState = new State(new Set(), numSymbols);
+  var initialState = new State(root.firstpos, numSymbols);
+  var dstates = [failState, initialState]; // while there is an unmarked state S in dstates
+
+  while (1) {
+    var s = null;
+
+    for (var j = 1; j < dstates.length; j++) {
+      if (!dstates[j].marked) {
+        s = dstates[j];
+        break;
+      }
+    }
+
+    if (s == null) {
+      break;
+    } // mark S
+
+
+    s.marked = true; // for each input symbol a
+
+    for (var a = 0; a < numSymbols; a++) {
+      // let U be the union of followpos(p) for all
+      //  p in S that correspond to a
+      var u = new Set();
+
+      for (var p of s.positions) {
+        if (p instanceof Literal && p.value === a) {
+          addAll(u, p.followpos);
+        }
+      }
+
+      if (u.size === 0) {
+        continue;
+      } // if U is not in dstates
+
+
+      var ux = -1;
+
+      for (var i = 0; i < dstates.length; i++) {
+        if (equal(u, dstates[i].positions)) {
+          ux = i;
+          break;
+        }
+      }
+
+      if (ux === -1) {
+        // Add U as an unmarked state to dstates
+        dstates.push(new State(u, numSymbols));
+        ux = dstates.length - 1;
+      }
+
+      s.transitions[a] = ux;
+    }
+  }
+
+  return dstates;
+}
+
+class State {
+  constructor(positions, len) {
+    this.positions = positions;
+    this.transitions = new Uint16Array(len);
+    this.accepting = positions.has(END_MARKER);
+    this.marked = false;
+    this.tags = new Set();
+
+    for (var pos of positions) {
+      if (pos instanceof Tag) {
+        this.tags.add(pos.name);
+      }
+    }
+  }
+
+}
+
+var INITIAL_STATE = 1;
+var FAIL_STATE = 0;
+/**
+ * A StateMachine represents a deterministic finite automaton.
+ * It can perform matches over a sequence of values, similar to a regular expression.
+ */
+
+class StateMachine {
+  constructor(dfa) {
+    this.stateTable = dfa.stateTable;
+    this.accepting = dfa.accepting;
+    this.tags = dfa.tags;
+  }
+  /**
+   * Returns an iterable object that yields pattern matches over the input sequence.
+   * Matches are of the form [startIndex, endIndex, tags].
+   */
+
+
+  match(str) {
+    var self = this;
+    return {
+      *[Symbol.iterator]() {
+        var state = INITIAL_STATE;
+        var startRun = null;
+        var lastAccepting = null;
+        var lastState = null;
+
+        for (var p = 0; p < str.length; p++) {
+          var c = str[p];
+          lastState = state;
+          state = self.stateTable[state][c];
+
+          if (state === FAIL_STATE) {
+            // yield the last match if any
+            if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
+              yield [startRun, lastAccepting, self.tags[lastState]];
+            } // reset the state as if we started over from the initial state
+
+
+            state = self.stateTable[INITIAL_STATE][c];
+            startRun = null;
+          } // start a run if not in the failure state
+
+
+          if (state !== FAIL_STATE && startRun == null) {
+            startRun = p;
+          } // if accepting, mark the potential match end
+
+
+          if (self.accepting[state]) {
+            lastAccepting = p;
+          } // reset the state to the initial state if we get into the failure state
+
+
+          if (state === FAIL_STATE) {
+            state = INITIAL_STATE;
+          }
+        } // yield the last match if any
+
+
+        if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
+          yield [startRun, lastAccepting, self.tags[state]];
+        }
+      }
+
+    };
+  }
+  /**
+   * For each match over the input sequence, action functions matching
+   * the tag definitions in the input pattern are called with the startIndex,
+   * endIndex, and sub-match sequence.
+   */
+
+
+  apply(str, actions) {
+    for (var [start, end, tags] of this.match(str)) {
+      for (var tag of tags) {
+        if (typeof actions[tag] === 'function') {
+          actions[tag](start, end, str.slice(start, end + 1));
+        }
+      }
+    }
+  }
+
+}
+
+function parse(string, externalSymbols) {
+  var ast = grammar.parse(string);
+  return new SymbolTable(ast, externalSymbols);
+}
+function build(symbolTable) {
+  var states = buildDFA(symbolTable.main, symbolTable.size);
+  return new StateMachine({
+    stateTable: states.map(s => Array.from(s.transitions)),
+    accepting: states.map(s => s.accepting),
+    tags: states.map(s => Array.from(s.tags))
+  });
+}
+function compile(string, externalSymbols) {
+  return build(parse(string, externalSymbols));
+}
+
+exports.build = build;
+exports.default = compile;
+exports.parse = parse;
+//# sourceMappingURL=compile.js.map

landvex-admin-v2/node_modules/dfa/index.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var INITIAL_STATE = 1;
+var FAIL_STATE = 0;
+/**
+ * A StateMachine represents a deterministic finite automaton.
+ * It can perform matches over a sequence of values, similar to a regular expression.
+ */
+
+class StateMachine {
+  constructor(dfa) {
+    this.stateTable = dfa.stateTable;
+    this.accepting = dfa.accepting;
+    this.tags = dfa.tags;
+  }
+  /**
+   * Returns an iterable object that yields pattern matches over the input sequence.
+   * Matches are of the form [startIndex, endIndex, tags].
+   */
+
+
+  match(str) {
+    var self = this;
+    return {
+      *[Symbol.iterator]() {
+        var state = INITIAL_STATE;
+        var startRun = null;
+        var lastAccepting = null;
+        var lastState = null;
+
+        for (var p = 0; p < str.length; p++) {
+          var c = str[p];
+          lastState = state;
+          state = self.stateTable[state][c];
+
+          if (state === FAIL_STATE) {
+            // yield the last match if any
+            if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
+              yield [startRun, lastAccepting, self.tags[lastState]];
+            } // reset the state as if we started over from the initial state
+
+
+            state = self.stateTable[INITIAL_STATE][c];
+            startRun = null;
+          } // start a run if not in the failure state
+
+
+          if (state !== FAIL_STATE && startRun == null) {
+            startRun = p;
+          } // if accepting, mark the potential match end
+
+
+          if (self.accepting[state]) {
+            lastAccepting = p;
+          } // reset the state to the initial state if we get into the failure state
+
+
+          if (state === FAIL_STATE) {
+            state = INITIAL_STATE;
+          }
+        } // yield the last match if any
+
+
+        if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {
+          yield [startRun, lastAccepting, self.tags[state]];
+        }
+      }
+
+    };
+  }
+  /**
+   * For each match over the input sequence, action functions matching
+   * the tag definitions in the input pattern are called with the startIndex,
+   * endIndex, and sub-match sequence.
+   */
+
+
+  apply(str, actions) {
+    for (var [start, end, tags] of this.match(str)) {
+      for (var tag of tags) {
+        if (typeof actions[tag] === 'function') {
+          actions[tag](start, end, str.slice(start, end + 1));
+        }
+      }
+    }
+  }
+
+}
+
+module.exports = StateMachine;
+//# sourceMappingURL=index.js.map

landvex-admin-v2/node_modules/dfa/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["src/StateMachine.js"],"sourcesContent":["const INITIAL_STATE = 1;\nconst FAIL_STATE = 0;\n\n/**\n * A StateMachine represents a deterministic finite automaton.\n * It can perform matches over a sequence of values, similar to a regular expression.\n */\nexport default class StateMachine {\n  constructor(dfa) {\n    this.stateTable = dfa.stateTable;\n    this.accepting = dfa.accepting;\n    this.tags = dfa.tags;\n  }\n\n  /**\n   * Returns an iterable object that yields pattern matches over the input sequence.\n   * Matches are of the form [startIndex, endIndex, tags].\n   */\n  match(str) {\n    let self = this;\n    return {\n      *[Symbol.iterator]() {\n        let state = INITIAL_STATE;\n        let startRun = null;\n        let lastAccepting = null;\n        let lastState = null;\n\n        for (let p = 0; p < str.length; p++) {\n          let c = str[p];\n\n          lastState = state;\n          state = self.stateTable[state][c];\n\n          if (state === FAIL_STATE) {\n            // yield the last match if any\n            if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {\n              yield [startRun, lastAccepting, self.tags[lastState]];\n            }\n\n            // reset the state as if we started over from the initial state\n            state = self.stateTable[INITIAL_STATE][c];\n            startRun = null;\n          }\n\n          // start a run if not in the failure state\n          if (state !== FAIL_STATE && startRun == null) {\n            startRun = p;\n          }\n\n          // if accepting, mark the potential match end\n          if (self.accepting[state]) {\n            lastAccepting = p;\n          }\n\n          // reset the state to the initial state if we get into the failure state\n          if (state === FAIL_STATE) {\n            state = INITIAL_STATE;\n          }\n        }\n\n        // yield the last match if any\n        if (startRun != null && lastAccepting != null && lastAccepting >= startRun) {\n          yield [startRun, lastAccepting, self.tags[state]];\n        }\n      }\n    };\n  }\n\n  /**\n   * For each match over the input sequence, action functions matching\n   * the tag definitions in the input pattern are called with the startIndex,\n   * endIndex, and sub-match sequence.\n   */\n  apply(str, actions) {\n    for (let [start, end, tags] of this.match(str)) {\n      for (let tag of tags) {\n        if (typeof actions[tag] === 'function') {\n          actions[tag](start, end, str.slice(start, end + 1));\n        }\n      }\n    }\n  }\n}\n"],"names":["INITIAL_STATE","FAIL_STATE","StateMachine","constructor","dfa","stateTable","accepting","tags","match","str","self","Symbol","iterator","state","startRun","lastAccepting","lastState","p","length","c","apply","actions","start","end","tag","slice"],"mappings":";;AAAA,IAAMA,aAAa,GAAG,CAAtB;AACA,IAAMC,UAAU,GAAG,CAAnB;;;;;;AAMA,AAAe,MAAMC,YAAN,CAAmB;EAChCC,WAAW,CAACC,GAAD,EAAM;SACVC,UAAL,GAAkBD,GAAG,CAACC,UAAtB;SACKC,SAAL,GAAiBF,GAAG,CAACE,SAArB;SACKC,IAAL,GAAYH,GAAG,CAACG,IAAhB;;;;;;;;EAOFC,KAAK,CAACC,GAAD,EAAM;QACLC,IAAI,GAAG,IAAX;WACO;QACHC,MAAM,CAACC,QAAT,IAAqB;YACfC,KAAK,GAAGb,aAAZ;YACIc,QAAQ,GAAG,IAAf;YACIC,aAAa,GAAG,IAApB;YACIC,SAAS,GAAG,IAAhB;;aAEK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGR,GAAG,CAACS,MAAxB,EAAgCD,CAAC,EAAjC,EAAqC;cAC/BE,CAAC,GAAGV,GAAG,CAACQ,CAAD,CAAX;UAEAD,SAAS,GAAGH,KAAZ;UACAA,KAAK,GAAGH,IAAI,CAACL,UAAL,CAAgBQ,KAAhB,EAAuBM,CAAvB,CAAR;;cAEIN,KAAK,KAAKZ,UAAd,EAA0B;;gBAEpBa,QAAQ,IAAI,IAAZ,IAAoBC,aAAa,IAAI,IAArC,IAA6CA,aAAa,IAAID,QAAlE,EAA4E;oBACpE,CAACA,QAAD,EAAWC,aAAX,EAA0BL,IAAI,CAACH,IAAL,CAAUS,SAAV,CAA1B,CAAN;aAHsB;;;YAOxBH,KAAK,GAAGH,IAAI,CAACL,UAAL,CAAgBL,aAAhB,EAA+BmB,CAA/B,CAAR;YACAL,QAAQ,GAAG,IAAX;WAdiC;;;cAkB/BD,KAAK,KAAKZ,UAAV,IAAwBa,QAAQ,IAAI,IAAxC,EAA8C;YAC5CA,QAAQ,GAAGG,CAAX;WAnBiC;;;cAuB/BP,IAAI,CAACJ,SAAL,CAAeO,KAAf,CAAJ,EAA2B;YACzBE,aAAa,GAAGE,CAAhB;WAxBiC;;;cA4B/BJ,KAAK,KAAKZ,UAAd,EAA0B;YACxBY,KAAK,GAAGb,aAAR;;SAnCe;;;YAwCfc,QAAQ,IAAI,IAAZ,IAAoBC,aAAa,IAAI,IAArC,IAA6CA,aAAa,IAAID,QAAlE,EAA4E;gBACpE,CAACA,QAAD,EAAWC,aAAX,EAA0BL,IAAI,CAACH,IAAL,CAAUM,KAAV,CAA1B,CAAN;;;;KA1CN;;;;;;;;;EAqDFO,KAAK,CAACX,GAAD,EAAMY,OAAN,EAAe;SACb,IAAI,CAACC,KAAD,EAAQC,GAAR,EAAahB,IAAb,CAAT,IAA+B,KAAKC,KAAL,CAAWC,GAAX,CAA/B,EAAgD;WACzC,IAAIe,GAAT,IAAgBjB,IAAhB,EAAsB;YAChB,OAAOc,OAAO,CAACG,GAAD,CAAd,KAAwB,UAA5B,EAAwC;UACtCH,OAAO,CAACG,GAAD,CAAP,CAAaF,KAAb,EAAoBC,GAApB,EAAyBd,GAAG,CAACgB,KAAJ,CAAUH,KAAV,EAAiBC,GAAG,GAAG,CAAvB,CAAzB;;;;;;;;;;"}

landvex-admin-v2/node_modules/dfa/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "dfa",
+  "version": "1.2.0",
+  "description": "A state machine compiler",
+  "main": "index.js",
+  "devDependencies": {
+    "@babel/core": "^7.0.0",
+    "@babel/preset-env": "^7.0.0",
+    "@babel/register": "^7.0.0",
+    "mocha": "^3.1.0",
+    "pegjs": "^0.10.0",
+    "rollup": "^1.5.0",
+    "rollup-plugin-babel": "^4.0.1",
+    "rollup-plugin-commonjs": "^9.2.1",
+    "rollup-plugin-local-resolve": "^1.0.7"
+  },
+  "scripts": {
+    "test": "mocha --require @babel/register",
+    "prepublish": "make"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/devongovett/dfa.git"
+  },
+  "keywords": [
+    "state",
+    "machine",
+    "compiler"
+  ],
+  "author": "Devon Govett <devongovett@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/devongovett/dfa/issues"
+  },
+  "homepage": "https://github.com/devongovett/dfa#readme",
+  "files": [
+    "index.js",
+    "index.js.map",
+    "compile.js",
+    "compile.js.map"
+  ]
+}