purity-seal 0.0.0

package/dist/nodejs.js

@@ -0,0 +1,2575 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/luaparse/luaparse.js
+var require_luaparse = __commonJS({
+  "node_modules/luaparse/luaparse.js"(exports, module) {
+    "use strict";
+    (function(root, name, factory) {
+      "use strict";
+      var objectTypes = {
+        "function": true,
+        "object": true
+      }, freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports, freeModule = objectTypes[typeof module] && module && !module.nodeType && module, freeGlobal = freeExports && freeModule && typeof global === "object" && global, moduleExports = freeModule && freeModule.exports === freeExports && freeExports;
+      if (freeGlobal && (freeGlobal.global === freeGlobal || /* istanbul ignore next */
+      freeGlobal.window === freeGlobal || /* istanbul ignore next */
+      freeGlobal.self === freeGlobal)) {
+        root = freeGlobal;
+      }
+      if (typeof define === "function" && /* istanbul ignore next */
+      typeof define.amd === "object" && /* istanbul ignore next */
+      define.amd) {
+        define(["exports"], factory);
+        if (freeExports && moduleExports) factory(freeModule.exports);
+      } else if (freeExports && freeModule) {
+        if (moduleExports) factory(freeModule.exports);
+        else factory(freeExports);
+      } else {
+        factory(root[name] = {});
+      }
+    })(exports, "luaparse", function(exports2) {
+      "use strict";
+      exports2.version = "0.3.1";
+      var input, options, length, features, encodingMode;
+      var defaultOptions = exports2.defaultOptions = {
+        // Explicitly tell the parser when the input ends.
+        wait: false,
+        comments: true,
+        scope: false,
+        locations: false,
+        ranges: false,
+        onCreateNode: null,
+        onCreateScope: null,
+        onDestroyScope: null,
+        onLocalDeclaration: null,
+        luaVersion: "5.1",
+        encodingMode: "none"
+      };
+      function encodeUTF8(codepoint, highMask) {
+        highMask = highMask || 0;
+        if (codepoint < 128) {
+          return String.fromCharCode(codepoint);
+        } else if (codepoint < 2048) {
+          return String.fromCharCode(
+            highMask | 192 | codepoint >> 6,
+            highMask | 128 | codepoint & 63
+          );
+        } else if (codepoint < 65536) {
+          return String.fromCharCode(
+            highMask | 224 | codepoint >> 12,
+            highMask | 128 | codepoint >> 6 & 63,
+            highMask | 128 | codepoint & 63
+          );
+        } else if (codepoint < 1114112) {
+          return String.fromCharCode(
+            highMask | 240 | codepoint >> 18,
+            highMask | 128 | codepoint >> 12 & 63,
+            highMask | 128 | codepoint >> 6 & 63,
+            highMask | 128 | codepoint & 63
+          );
+        } else {
+          return null;
+        }
+      }
+      function toHex(num, digits) {
+        var result = num.toString(16);
+        while (result.length < digits)
+          result = "0" + result;
+        return result;
+      }
+      function checkChars(rx) {
+        return function(s) {
+          var m = rx.exec(s);
+          if (!m)
+            return s;
+          raise(null, errors.invalidCodeUnit, toHex(m[0].charCodeAt(0), 4).toUpperCase());
+        };
+      }
+      var encodingModes = {
+        // `pseudo-latin1` encoding mode: assume the input was decoded with the latin1 encoding
+        // WARNING: latin1 does **NOT** mean cp1252 here like in the bone-headed WHATWG standard;
+        // it means true ISO/IEC 8859-1 identity-mapped to Basic Latin and Latin-1 Supplement blocks
+        "pseudo-latin1": {
+          fixup: checkChars(/[^\x00-\xff]/),
+          encodeByte: function(value) {
+            if (value === null)
+              return "";
+            return String.fromCharCode(value);
+          },
+          encodeUTF8: function(codepoint) {
+            return encodeUTF8(codepoint);
+          }
+        },
+        // `x-user-defined` encoding mode: assume the input was decoded with the WHATWG `x-user-defined` encoding
+        "x-user-defined": {
+          fixup: checkChars(/[^\x00-\x7f\uf780-\uf7ff]/),
+          encodeByte: function(value) {
+            if (value === null)
+              return "";
+            if (value >= 128)
+              return String.fromCharCode(value | 63232);
+            return String.fromCharCode(value);
+          },
+          encodeUTF8: function(codepoint) {
+            return encodeUTF8(codepoint, 63232);
+          }
+        },
+        // `none` encoding mode: disregard intrepretation of string literals, leave identifiers as-is
+        "none": {
+          discardStrings: true,
+          fixup: function(s) {
+            return s;
+          },
+          encodeByte: function(value) {
+            return "";
+          },
+          encodeUTF8: function(codepoint) {
+            return "";
+          }
+        }
+      };
+      var EOF = 1, StringLiteral = 2, Keyword = 4, Identifier = 8, NumericLiteral = 16, Punctuator = 32, BooleanLiteral = 64, NilLiteral = 128, VarargLiteral = 256;
+      exports2.tokenTypes = {
+        EOF,
+        StringLiteral,
+        Keyword,
+        Identifier,
+        NumericLiteral,
+        Punctuator,
+        BooleanLiteral,
+        NilLiteral,
+        VarargLiteral
+      };
+      var errors = exports2.errors = {
+        unexpected: "unexpected %1 '%2' near '%3'",
+        unexpectedEOF: "unexpected symbol near '<eof>'",
+        expected: "'%1' expected near '%2'",
+        expectedToken: "%1 expected near '%2'",
+        unfinishedString: "unfinished string near '%1'",
+        malformedNumber: "malformed number near '%1'",
+        decimalEscapeTooLarge: "decimal escape too large near '%1'",
+        invalidEscape: "invalid escape sequence near '%1'",
+        hexadecimalDigitExpected: "hexadecimal digit expected near '%1'",
+        braceExpected: "missing '%1' near '%2'",
+        tooLargeCodepoint: "UTF-8 value too large near '%1'",
+        unfinishedLongString: "unfinished long string (starting at line %1) near '%2'",
+        unfinishedLongComment: "unfinished long comment (starting at line %1) near '%2'",
+        ambiguousSyntax: "ambiguous syntax (function call x new statement) near '%1'",
+        noLoopToBreak: "no loop to break near '%1'",
+        labelAlreadyDefined: "label '%1' already defined on line %2",
+        labelNotVisible: "no visible label '%1' for <goto>",
+        gotoJumpInLocalScope: "<goto %1> jumps into the scope of local '%2'",
+        cannotUseVararg: "cannot use '...' outside a vararg function near '%1'",
+        invalidCodeUnit: "code unit U+%1 is not allowed in the current encoding mode"
+      };
+      var ast = exports2.ast = {
+        labelStatement: function(label) {
+          return {
+            type: "LabelStatement",
+            label
+          };
+        },
+        breakStatement: function() {
+          return {
+            type: "BreakStatement"
+          };
+        },
+        gotoStatement: function(label) {
+          return {
+            type: "GotoStatement",
+            label
+          };
+        },
+        returnStatement: function(args) {
+          return {
+            type: "ReturnStatement",
+            "arguments": args
+          };
+        },
+        ifStatement: function(clauses) {
+          return {
+            type: "IfStatement",
+            clauses
+          };
+        },
+        ifClause: function(condition, body) {
+          return {
+            type: "IfClause",
+            condition,
+            body
+          };
+        },
+        elseifClause: function(condition, body) {
+          return {
+            type: "ElseifClause",
+            condition,
+            body
+          };
+        },
+        elseClause: function(body) {
+          return {
+            type: "ElseClause",
+            body
+          };
+        },
+        whileStatement: function(condition, body) {
+          return {
+            type: "WhileStatement",
+            condition,
+            body
+          };
+        },
+        doStatement: function(body) {
+          return {
+            type: "DoStatement",
+            body
+          };
+        },
+        repeatStatement: function(condition, body) {
+          return {
+            type: "RepeatStatement",
+            condition,
+            body
+          };
+        },
+        localStatement: function(variables, init) {
+          return {
+            type: "LocalStatement",
+            variables,
+            init
+          };
+        },
+        assignmentStatement: function(variables, init) {
+          return {
+            type: "AssignmentStatement",
+            variables,
+            init
+          };
+        },
+        callStatement: function(expression) {
+          return {
+            type: "CallStatement",
+            expression
+          };
+        },
+        functionStatement: function(identifier, parameters, isLocal, body) {
+          return {
+            type: "FunctionDeclaration",
+            identifier,
+            isLocal,
+            parameters,
+            body
+          };
+        },
+        forNumericStatement: function(variable, start, end2, step, body) {
+          return {
+            type: "ForNumericStatement",
+            variable,
+            start,
+            end: end2,
+            step,
+            body
+          };
+        },
+        forGenericStatement: function(variables, iterators, body) {
+          return {
+            type: "ForGenericStatement",
+            variables,
+            iterators,
+            body
+          };
+        },
+        chunk: function(body) {
+          return {
+            type: "Chunk",
+            body
+          };
+        },
+        identifier: function(name) {
+          return {
+            type: "Identifier",
+            name
+          };
+        },
+        literal: function(type, value, raw) {
+          type = type === StringLiteral ? "StringLiteral" : type === NumericLiteral ? "NumericLiteral" : type === BooleanLiteral ? "BooleanLiteral" : type === NilLiteral ? "NilLiteral" : "VarargLiteral";
+          return {
+            type,
+            value,
+            raw
+          };
+        },
+        tableKey: function(key, value) {
+          return {
+            type: "TableKey",
+            key,
+            value
+          };
+        },
+        tableKeyString: function(key, value) {
+          return {
+            type: "TableKeyString",
+            key,
+            value
+          };
+        },
+        tableValue: function(value) {
+          return {
+            type: "TableValue",
+            value
+          };
+        },
+        tableConstructorExpression: function(fields) {
+          return {
+            type: "TableConstructorExpression",
+            fields
+          };
+        },
+        binaryExpression: function(operator, left, right) {
+          var type = "and" === operator || "or" === operator ? "LogicalExpression" : "BinaryExpression";
+          return {
+            type,
+            operator,
+            left,
+            right
+          };
+        },
+        unaryExpression: function(operator, argument) {
+          return {
+            type: "UnaryExpression",
+            operator,
+            argument
+          };
+        },
+        memberExpression: function(base, indexer, identifier) {
+          return {
+            type: "MemberExpression",
+            indexer,
+            identifier,
+            base
+          };
+        },
+        indexExpression: function(base, index2) {
+          return {
+            type: "IndexExpression",
+            base,
+            index: index2
+          };
+        },
+        callExpression: function(base, args) {
+          return {
+            type: "CallExpression",
+            base,
+            "arguments": args
+          };
+        },
+        tableCallExpression: function(base, args) {
+          return {
+            type: "TableCallExpression",
+            base,
+            "arguments": args
+          };
+        },
+        stringCallExpression: function(base, argument) {
+          return {
+            type: "StringCallExpression",
+            base,
+            argument
+          };
+        },
+        comment: function(value, raw) {
+          return {
+            type: "Comment",
+            value,
+            raw
+          };
+        }
+      };
+      function finishNode(node) {
+        if (trackLocations) {
+          var location = locations.pop();
+          location.complete();
+          location.bless(node);
+        }
+        if (options.onCreateNode) options.onCreateNode(node);
+        return node;
+      }
+      var slice = Array.prototype.slice, toString = Object.prototype.toString;
+      var indexOf = (
+        /* istanbul ignore next */
+        function(array, element) {
+          for (var i = 0, length2 = array.length; i < length2; ++i) {
+            if (array[i] === element) return i;
+          }
+          return -1;
+        }
+      );
+      if (Array.prototype.indexOf)
+        indexOf = function(array, element) {
+          return array.indexOf(element);
+        };
+      function indexOfObject(array, property, element) {
+        for (var i = 0, length2 = array.length; i < length2; ++i) {
+          if (array[i][property] === element) return i;
+        }
+        return -1;
+      }
+      function sprintf(format) {
+        var args = slice.call(arguments, 1);
+        format = format.replace(/%(\d)/g, function(match, index2) {
+          return "" + args[index2 - 1] || /* istanbul ignore next */
+          "";
+        });
+        return format;
+      }
+      var assign = (
+        /* istanbul ignore next */
+        function(dest) {
+          var args = slice.call(arguments, 1), src, prop;
+          for (var i = 0, length2 = args.length; i < length2; ++i) {
+            src = args[i];
+            for (prop in src)
+              if (Object.prototype.hasOwnProperty.call(src, prop)) {
+                dest[prop] = src[prop];
+              }
+          }
+          return dest;
+        }
+      );
+      if (Object.assign)
+        assign = Object.assign;
+      exports2.SyntaxError = SyntaxError;
+      function fixupError(e) {
+        if (!Object.create)
+          return e;
+        return Object.create(e, {
+          "line": { "writable": true, value: e.line },
+          "index": { "writable": true, value: e.index },
+          "column": { "writable": true, value: e.column }
+        });
+      }
+      function raise(token2) {
+        var message = sprintf.apply(null, slice.call(arguments, 1)), error, col;
+        if (token2 === null || typeof token2.line === "undefined") {
+          col = index - lineStart + 1;
+          error = fixupError(new SyntaxError(sprintf("[%1:%2] %3", line, col, message)));
+          error.index = index;
+          error.line = line;
+          error.column = col;
+        } else {
+          col = token2.range[0] - token2.lineStart;
+          error = fixupError(new SyntaxError(sprintf("[%1:%2] %3", token2.line, col, message)));
+          error.line = token2.line;
+          error.index = token2.range[0];
+          error.column = col;
+        }
+        throw error;
+      }
+      function tokenValue(token2) {
+        var raw = input.slice(token2.range[0], token2.range[1]);
+        if (raw)
+          return raw;
+        return token2.value;
+      }
+      function raiseUnexpectedToken(type, token2) {
+        raise(token2, errors.expectedToken, type, tokenValue(token2));
+      }
+      function unexpected(found) {
+        var near = tokenValue(lookahead);
+        if ("undefined" !== typeof found.type) {
+          var type;
+          switch (found.type) {
+            case StringLiteral:
+              type = "string";
+              break;
+            case Keyword:
+              type = "keyword";
+              break;
+            case Identifier:
+              type = "identifier";
+              break;
+            case NumericLiteral:
+              type = "number";
+              break;
+            case Punctuator:
+              type = "symbol";
+              break;
+            case BooleanLiteral:
+              type = "boolean";
+              break;
+            case NilLiteral:
+              return raise(found, errors.unexpected, "symbol", "nil", near);
+            case EOF:
+              return raise(found, errors.unexpectedEOF);
+          }
+          return raise(found, errors.unexpected, type, tokenValue(found), near);
+        }
+        return raise(found, errors.unexpected, "symbol", found, near);
+      }
+      var index, token, previousToken, lookahead, comments, tokenStart, line, lineStart;
+      exports2.lex = lex;
+      function lex() {
+        skipWhiteSpace();
+        while (45 === input.charCodeAt(index) && 45 === input.charCodeAt(index + 1)) {
+          scanComment();
+          skipWhiteSpace();
+        }
+        if (index >= length) return {
+          type: EOF,
+          value: "<eof>",
+          line,
+          lineStart,
+          range: [index, index]
+        };
+        var charCode = input.charCodeAt(index), next2 = input.charCodeAt(index + 1);
+        tokenStart = index;
+        if (isIdentifierStart(charCode)) return scanIdentifierOrKeyword();
+        switch (charCode) {
+          case 39:
+          case 34:
+            return scanStringLiteral();
+          case 48:
+          case 49:
+          case 50:
+          case 51:
+          case 52:
+          case 53:
+          case 54:
+          case 55:
+          case 56:
+          case 57:
+            return scanNumericLiteral();
+          case 46:
+            if (isDecDigit(next2)) return scanNumericLiteral();
+            if (46 === next2) {
+              if (46 === input.charCodeAt(index + 2)) return scanVarargLiteral();
+              return scanPunctuator("..");
+            }
+            return scanPunctuator(".");
+          case 61:
+            if (61 === next2) return scanPunctuator("==");
+            return scanPunctuator("=");
+          case 62:
+            if (features.bitwiseOperators) {
+              if (62 === next2) return scanPunctuator(">>");
+            }
+            if (61 === next2) return scanPunctuator(">=");
+            return scanPunctuator(">");
+          case 60:
+            if (features.bitwiseOperators) {
+              if (60 === next2) return scanPunctuator("<<");
+            }
+            if (61 === next2) return scanPunctuator("<=");
+            return scanPunctuator("<");
+          case 126:
+            if (61 === next2) return scanPunctuator("~=");
+            if (!features.bitwiseOperators)
+              break;
+            return scanPunctuator("~");
+          case 58:
+            if (features.labels) {
+              if (58 === next2) return scanPunctuator("::");
+            }
+            return scanPunctuator(":");
+          case 91:
+            if (91 === next2 || 61 === next2) return scanLongStringLiteral();
+            return scanPunctuator("[");
+          case 47:
+            if (features.integerDivision) {
+              if (47 === next2) return scanPunctuator("//");
+            }
+            return scanPunctuator("/");
+          case 38:
+          case 124:
+            if (!features.bitwiseOperators)
+              break;
+          /* fall through */
+          case 42:
+          case 94:
+          case 37:
+          case 44:
+          case 123:
+          case 125:
+          case 93:
+          case 40:
+          case 41:
+          case 59:
+          case 35:
+          case 45:
+          case 43:
+            return scanPunctuator(input.charAt(index));
+        }
+        return unexpected(input.charAt(index));
+      }
+      function consumeEOL() {
+        var charCode = input.charCodeAt(index), peekCharCode = input.charCodeAt(index + 1);
+        if (isLineTerminator(charCode)) {
+          if (10 === charCode && 13 === peekCharCode) ++index;
+          if (13 === charCode && 10 === peekCharCode) ++index;
+          ++line;
+          lineStart = ++index;
+          return true;
+        }
+        return false;
+      }
+      function skipWhiteSpace() {
+        while (index < length) {
+          var charCode = input.charCodeAt(index);
+          if (isWhiteSpace(charCode)) {
+            ++index;
+          } else if (!consumeEOL()) {
+            break;
+          }
+        }
+      }
+      function scanIdentifierOrKeyword() {
+        var value, type;
+        while (isIdentifierPart(input.charCodeAt(++index))) ;
+        value = encodingMode.fixup(input.slice(tokenStart, index));
+        if (isKeyword(value)) {
+          type = Keyword;
+        } else if ("true" === value || "false" === value) {
+          type = BooleanLiteral;
+          value = "true" === value;
+        } else if ("nil" === value) {
+          type = NilLiteral;
+          value = null;
+        } else {
+          type = Identifier;
+        }
+        return {
+          type,
+          value,
+          line,
+          lineStart,
+          range: [tokenStart, index]
+        };
+      }
+      function scanPunctuator(value) {
+        index += value.length;
+        return {
+          type: Punctuator,
+          value,
+          line,
+          lineStart,
+          range: [tokenStart, index]
+        };
+      }
+      function scanVarargLiteral() {
+        index += 3;
+        return {
+          type: VarargLiteral,
+          value: "...",
+          line,
+          lineStart,
+          range: [tokenStart, index]
+        };
+      }
+      function scanStringLiteral() {
+        var delimiter = input.charCodeAt(index++), beginLine = line, beginLineStart = lineStart, stringStart = index, string = encodingMode.discardStrings ? null : "", charCode;
+        for (; ; ) {
+          charCode = input.charCodeAt(index++);
+          if (delimiter === charCode) break;
+          if (index > length || isLineTerminator(charCode)) {
+            string += input.slice(stringStart, index - 1);
+            raise(null, errors.unfinishedString, input.slice(tokenStart, index - 1));
+          }
+          if (92 === charCode) {
+            if (!encodingMode.discardStrings) {
+              var beforeEscape = input.slice(stringStart, index - 1);
+              string += encodingMode.fixup(beforeEscape);
+            }
+            var escapeValue = readEscapeSequence();
+            if (!encodingMode.discardStrings)
+              string += escapeValue;
+            stringStart = index;
+          }
+        }
+        if (!encodingMode.discardStrings) {
+          string += encodingMode.encodeByte(null);
+          string += encodingMode.fixup(input.slice(stringStart, index - 1));
+        }
+        return {
+          type: StringLiteral,
+          value: string,
+          line: beginLine,
+          lineStart: beginLineStart,
+          lastLine: line,
+          lastLineStart: lineStart,
+          range: [tokenStart, index]
+        };
+      }
+      function scanLongStringLiteral() {
+        var beginLine = line, beginLineStart = lineStart, string = readLongString(false);
+        if (false === string) raise(token, errors.expected, "[", tokenValue(token));
+        return {
+          type: StringLiteral,
+          value: encodingMode.discardStrings ? null : encodingMode.fixup(string),
+          line: beginLine,
+          lineStart: beginLineStart,
+          lastLine: line,
+          lastLineStart: lineStart,
+          range: [tokenStart, index]
+        };
+      }
+      function scanNumericLiteral() {
+        var character = input.charAt(index), next2 = input.charAt(index + 1);
+        var literal = "0" === character && "xX".indexOf(next2 || null) >= 0 ? readHexLiteral() : readDecLiteral();
+        var foundImaginaryUnit = readImaginaryUnitSuffix(), foundInt64Suffix = readInt64Suffix();
+        if (foundInt64Suffix && (foundImaginaryUnit || literal.hasFractionPart)) {
+          raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+        }
+        return {
+          type: NumericLiteral,
+          value: literal.value,
+          line,
+          lineStart,
+          range: [tokenStart, index]
+        };
+      }
+      function readImaginaryUnitSuffix() {
+        if (!features.imaginaryNumbers) return;
+        if ("iI".indexOf(input.charAt(index) || null) >= 0) {
+          ++index;
+          return true;
+        } else {
+          return false;
+        }
+      }
+      function readInt64Suffix() {
+        if (!features.integerSuffixes) return;
+        if ("uU".indexOf(input.charAt(index) || null) >= 0) {
+          ++index;
+          if ("lL".indexOf(input.charAt(index) || null) >= 0) {
+            ++index;
+            if ("lL".indexOf(input.charAt(index) || null) >= 0) {
+              ++index;
+              return "ULL";
+            } else {
+              raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+            }
+          } else {
+            raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+          }
+        } else if ("lL".indexOf(input.charAt(index) || null) >= 0) {
+          ++index;
+          if ("lL".indexOf(input.charAt(index) || null) >= 0) {
+            ++index;
+            return "LL";
+          } else {
+            raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+          }
+        }
+      }
+      function readHexLiteral() {
+        var fraction = 0, binaryExponent = 1, binarySign = 1, digit, fractionStart, exponentStart, digitStart;
+        digitStart = index += 2;
+        if (!isHexDigit(input.charCodeAt(index)))
+          raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+        while (isHexDigit(input.charCodeAt(index))) ++index;
+        digit = parseInt(input.slice(digitStart, index), 16);
+        var foundFraction = false;
+        if ("." === input.charAt(index)) {
+          foundFraction = true;
+          fractionStart = ++index;
+          while (isHexDigit(input.charCodeAt(index))) ++index;
+          fraction = input.slice(fractionStart, index);
+          fraction = fractionStart === index ? 0 : parseInt(fraction, 16) / Math.pow(16, index - fractionStart);
+        }
+        var foundBinaryExponent = false;
+        if ("pP".indexOf(input.charAt(index) || null) >= 0) {
+          foundBinaryExponent = true;
+          ++index;
+          if ("+-".indexOf(input.charAt(index) || null) >= 0)
+            binarySign = "+" === input.charAt(index++) ? 1 : -1;
+          exponentStart = index;
+          if (!isDecDigit(input.charCodeAt(index)))
+            raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+          while (isDecDigit(input.charCodeAt(index))) ++index;
+          binaryExponent = input.slice(exponentStart, index);
+          binaryExponent = Math.pow(2, binaryExponent * binarySign);
+        }
+        return {
+          value: (digit + fraction) * binaryExponent,
+          hasFractionPart: foundFraction || foundBinaryExponent
+        };
+      }
+      function readDecLiteral() {
+        while (isDecDigit(input.charCodeAt(index))) ++index;
+        var foundFraction = false;
+        if ("." === input.charAt(index)) {
+          foundFraction = true;
+          ++index;
+          while (isDecDigit(input.charCodeAt(index))) ++index;
+        }
+        var foundExponent = false;
+        if ("eE".indexOf(input.charAt(index) || null) >= 0) {
+          foundExponent = true;
+          ++index;
+          if ("+-".indexOf(input.charAt(index) || null) >= 0) ++index;
+          if (!isDecDigit(input.charCodeAt(index)))
+            raise(null, errors.malformedNumber, input.slice(tokenStart, index));
+          while (isDecDigit(input.charCodeAt(index))) ++index;
+        }
+        return {
+          value: parseFloat(input.slice(tokenStart, index)),
+          hasFractionPart: foundFraction || foundExponent
+        };
+      }
+      function readUnicodeEscapeSequence() {
+        var sequenceStart = index++;
+        if (input.charAt(index++) !== "{")
+          raise(null, errors.braceExpected, "{", "\\" + input.slice(sequenceStart, index));
+        if (!isHexDigit(input.charCodeAt(index)))
+          raise(null, errors.hexadecimalDigitExpected, "\\" + input.slice(sequenceStart, index));
+        while (input.charCodeAt(index) === 48) ++index;
+        var escStart = index;
+        while (isHexDigit(input.charCodeAt(index))) {
+          ++index;
+          if (index - escStart > 6)
+            raise(null, errors.tooLargeCodepoint, "\\" + input.slice(sequenceStart, index));
+        }
+        var b = input.charAt(index++);
+        if (b !== "}") {
+          if (b === '"' || b === "'")
+            raise(null, errors.braceExpected, "}", "\\" + input.slice(sequenceStart, index--));
+          else
+            raise(null, errors.hexadecimalDigitExpected, "\\" + input.slice(sequenceStart, index));
+        }
+        var codepoint = parseInt(input.slice(escStart, index - 1) || "0", 16);
+        var frag = "\\" + input.slice(sequenceStart, index);
+        if (codepoint > 1114111) {
+          raise(null, errors.tooLargeCodepoint, frag);
+        }
+        return encodingMode.encodeUTF8(codepoint, frag);
+      }
+      function readEscapeSequence() {
+        var sequenceStart = index;
+        switch (input.charAt(index)) {
+          // Lua allow the following escape sequences.
+          case "a":
+            ++index;
+            return "\x07";
+          case "n":
+            ++index;
+            return "\n";
+          case "r":
+            ++index;
+            return "\r";
+          case "t":
+            ++index;
+            return "	";
+          case "v":
+            ++index;
+            return "\v";
+          case "b":
+            ++index;
+            return "\b";
+          case "f":
+            ++index;
+            return "\f";
+          // Backslash at the end of the line. We treat all line endings as equivalent,
+          // and as representing the [LF] character (code 10). Lua 5.1 through 5.3
+          // have been verified to behave the same way.
+          case "\r":
+          case "\n":
+            consumeEOL();
+            return "\n";
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9":
+            while (isDecDigit(input.charCodeAt(index)) && index - sequenceStart < 3) ++index;
+            var frag = input.slice(sequenceStart, index);
+            var ddd = parseInt(frag, 10);
+            if (ddd > 255) {
+              raise(null, errors.decimalEscapeTooLarge, "\\" + ddd);
+            }
+            return encodingMode.encodeByte(ddd, "\\" + frag);
+          case "z":
+            if (features.skipWhitespaceEscape) {
+              ++index;
+              skipWhiteSpace();
+              return "";
+            }
+            break;
+          case "x":
+            if (features.hexEscapes) {
+              if (isHexDigit(input.charCodeAt(index + 1)) && isHexDigit(input.charCodeAt(index + 2))) {
+                index += 3;
+                return encodingMode.encodeByte(parseInt(input.slice(sequenceStart + 1, index), 16), "\\" + input.slice(sequenceStart, index));
+              }
+              raise(null, errors.hexadecimalDigitExpected, "\\" + input.slice(sequenceStart, index + 2));
+            }
+            break;
+          case "u":
+            if (features.unicodeEscapes)
+              return readUnicodeEscapeSequence();
+            break;
+          case "\\":
+          case '"':
+          case "'":
+            return input.charAt(index++);
+        }
+        if (features.strictEscapes)
+          raise(null, errors.invalidEscape, "\\" + input.slice(sequenceStart, index + 1));
+        return input.charAt(index++);
+      }
+      function scanComment() {
+        tokenStart = index;
+        index += 2;
+        var character = input.charAt(index), content = "", isLong = false, commentStart = index, lineStartComment = lineStart, lineComment = line;
+        if ("[" === character) {
+          content = readLongString(true);
+          if (false === content) content = character;
+          else isLong = true;
+        }
+        if (!isLong) {
+          while (index < length) {
+            if (isLineTerminator(input.charCodeAt(index))) break;
+            ++index;
+          }
+          if (options.comments) content = input.slice(commentStart, index);
+        }
+        if (options.comments) {
+          var node = ast.comment(content, input.slice(tokenStart, index));
+          if (options.locations) {
+            node.loc = {
+              start: { line: lineComment, column: tokenStart - lineStartComment },
+              end: { line, column: index - lineStart }
+            };
+          }
+          if (options.ranges) {
+            node.range = [tokenStart, index];
+          }
+          if (options.onCreateNode) options.onCreateNode(node);
+          comments.push(node);
+        }
+      }
+      function readLongString(isComment) {
+        var level = 0, content = "", terminator = false, character, stringStart, firstLine = line;
+        ++index;
+        while ("=" === input.charAt(index + level)) ++level;
+        if ("[" !== input.charAt(index + level)) return false;
+        index += level + 1;
+        if (isLineTerminator(input.charCodeAt(index))) consumeEOL();
+        stringStart = index;
+        while (index < length) {
+          while (isLineTerminator(input.charCodeAt(index))) consumeEOL();
+          character = input.charAt(index++);
+          if ("]" === character) {
+            terminator = true;
+            for (var i = 0; i < level; ++i) {
+              if ("=" !== input.charAt(index + i)) terminator = false;
+            }
+            if ("]" !== input.charAt(index + level)) terminator = false;
+          }
+          if (terminator) {
+            content += input.slice(stringStart, index - 1);
+            index += level + 1;
+            return content;
+          }
+        }
+        raise(
+          null,
+          isComment ? errors.unfinishedLongComment : errors.unfinishedLongString,
+          firstLine,
+          "<eof>"
+        );
+      }
+      function next() {
+        previousToken = token;
+        token = lookahead;
+        lookahead = lex();
+      }
+      function consume(value) {
+        if (value === token.value) {
+          next();
+          return true;
+        }
+        return false;
+      }
+      function expect(value) {
+        if (value === token.value) next();
+        else raise(token, errors.expected, value, tokenValue(token));
+      }
+      function isWhiteSpace(charCode) {
+        return 9 === charCode || 32 === charCode || 11 === charCode || 12 === charCode;
+      }
+      function isLineTerminator(charCode) {
+        return 10 === charCode || 13 === charCode;
+      }
+      function isDecDigit(charCode) {
+        return charCode >= 48 && charCode <= 57;
+      }
+      function isHexDigit(charCode) {
+        return charCode >= 48 && charCode <= 57 || charCode >= 97 && charCode <= 102 || charCode >= 65 && charCode <= 70;
+      }
+      function isIdentifierStart(charCode) {
+        if (charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || 95 === charCode)
+          return true;
+        if (features.extendedIdentifiers && charCode >= 128)
+          return true;
+        return false;
+      }
+      function isIdentifierPart(charCode) {
+        if (charCode >= 65 && charCode <= 90 || charCode >= 97 && charCode <= 122 || 95 === charCode || charCode >= 48 && charCode <= 57)
+          return true;
+        if (features.extendedIdentifiers && charCode >= 128)
+          return true;
+        return false;
+      }
+      function isKeyword(id) {
+        switch (id.length) {
+          case 2:
+            return "do" === id || "if" === id || "in" === id || "or" === id;
+          case 3:
+            return "and" === id || "end" === id || "for" === id || "not" === id;
+          case 4:
+            if ("else" === id || "then" === id)
+              return true;
+            if (features.labels && !features.contextualGoto)
+              return "goto" === id;
+            return false;
+          case 5:
+            return "break" === id || "local" === id || "until" === id || "while" === id;
+          case 6:
+            return "elseif" === id || "repeat" === id || "return" === id;
+          case 8:
+            return "function" === id;
+        }
+        return false;
+      }
+      function isUnary(token2) {
+        if (Punctuator === token2.type) return "#-~".indexOf(token2.value) >= 0;
+        if (Keyword === token2.type) return "not" === token2.value;
+        return false;
+      }
+      function isBlockFollow(token2) {
+        if (EOF === token2.type) return true;
+        if (Keyword !== token2.type) return false;
+        switch (token2.value) {
+          case "else":
+          case "elseif":
+          case "end":
+          case "until":
+            return true;
+          default:
+            return false;
+        }
+      }
+      var scopes, scopeDepth, globals;
+      function createScope() {
+        var scope = scopes[scopeDepth++].slice();
+        scopes.push(scope);
+        if (options.onCreateScope) options.onCreateScope();
+      }
+      function destroyScope() {
+        var scope = scopes.pop();
+        --scopeDepth;
+        if (options.onDestroyScope) options.onDestroyScope();
+      }
+      function scopeIdentifierName(name) {
+        if (options.onLocalDeclaration) options.onLocalDeclaration(name);
+        if (-1 !== indexOf(scopes[scopeDepth], name)) return;
+        scopes[scopeDepth].push(name);
+      }
+      function scopeIdentifier(node) {
+        scopeIdentifierName(node.name);
+        attachScope(node, true);
+      }
+      function attachScope(node, isLocal) {
+        if (!isLocal && -1 === indexOfObject(globals, "name", node.name))
+          globals.push(node);
+        node.isLocal = isLocal;
+      }
+      function scopeHasName(name) {
+        return -1 !== indexOf(scopes[scopeDepth], name);
+      }
+      var locations = [], trackLocations;
+      function createLocationMarker() {
+        return new Marker(token);
+      }
+      function Marker(token2) {
+        if (options.locations) {
+          this.loc = {
+            start: {
+              line: token2.line,
+              column: token2.range[0] - token2.lineStart
+            },
+            end: {
+              line: 0,
+              column: 0
+            }
+          };
+        }
+        if (options.ranges) this.range = [token2.range[0], 0];
+      }
+      Marker.prototype.complete = function() {
+        if (options.locations) {
+          this.loc.end.line = previousToken.lastLine || previousToken.line;
+          this.loc.end.column = previousToken.range[1] - (previousToken.lastLineStart || previousToken.lineStart);
+        }
+        if (options.ranges) {
+          this.range[1] = previousToken.range[1];
+        }
+      };
+      Marker.prototype.bless = function(node) {
+        if (this.loc) {
+          var loc = this.loc;
+          node.loc = {
+            start: {
+              line: loc.start.line,
+              column: loc.start.column
+            },
+            end: {
+              line: loc.end.line,
+              column: loc.end.column
+            }
+          };
+        }
+        if (this.range) {
+          node.range = [
+            this.range[0],
+            this.range[1]
+          ];
+        }
+      };
+      function markLocation() {
+        if (trackLocations) locations.push(createLocationMarker());
+      }
+      function pushLocation(marker) {
+        if (trackLocations) locations.push(marker);
+      }
+      function FullFlowContext() {
+        this.scopes = [];
+        this.pendingGotos = [];
+      }
+      FullFlowContext.prototype.isInLoop = function() {
+        var i = this.scopes.length;
+        while (i-- > 0) {
+          if (this.scopes[i].isLoop)
+            return true;
+        }
+        return false;
+      };
+      FullFlowContext.prototype.pushScope = function(isLoop) {
+        var scope = {
+          labels: {},
+          locals: [],
+          deferredGotos: [],
+          isLoop: !!isLoop
+        };
+        this.scopes.push(scope);
+      };
+      FullFlowContext.prototype.popScope = function() {
+        for (var i = 0; i < this.pendingGotos.length; ++i) {
+          var theGoto = this.pendingGotos[i];
+          if (theGoto.maxDepth >= this.scopes.length) {
+            if (--theGoto.maxDepth <= 0)
+              raise(theGoto.token, errors.labelNotVisible, theGoto.target);
+          }
+        }
+        this.scopes.pop();
+      };
+      FullFlowContext.prototype.addGoto = function(target, token2) {
+        var localCounts = [];
+        for (var i = 0; i < this.scopes.length; ++i) {
+          var scope = this.scopes[i];
+          localCounts.push(scope.locals.length);
+          if (Object.prototype.hasOwnProperty.call(scope.labels, target))
+            return;
+        }
+        this.pendingGotos.push({
+          maxDepth: this.scopes.length,
+          target,
+          token: token2,
+          localCounts
+        });
+      };
+      FullFlowContext.prototype.addLabel = function(name, token2) {
+        var scope = this.currentScope();
+        if (Object.prototype.hasOwnProperty.call(scope.labels, name)) {
+          raise(token2, errors.labelAlreadyDefined, name, scope.labels[name].line);
+        } else {
+          var newGotos = [];
+          for (var i = 0; i < this.pendingGotos.length; ++i) {
+            var theGoto = this.pendingGotos[i];
+            if (theGoto.maxDepth >= this.scopes.length && theGoto.target === name) {
+              if (theGoto.localCounts[this.scopes.length - 1] < scope.locals.length) {
+                scope.deferredGotos.push(theGoto);
+              }
+              continue;
+            }
+            newGotos.push(theGoto);
+          }
+          this.pendingGotos = newGotos;
+        }
+        scope.labels[name] = {
+          localCount: scope.locals.length,
+          line: token2.line
+        };
+      };
+      FullFlowContext.prototype.addLocal = function(name, token2) {
+        this.currentScope().locals.push({
+          name,
+          token: token2
+        });
+      };
+      FullFlowContext.prototype.currentScope = function() {
+        return this.scopes[this.scopes.length - 1];
+      };
+      FullFlowContext.prototype.raiseDeferredErrors = function() {
+        var scope = this.currentScope();
+        var bads = scope.deferredGotos;
+        for (var i = 0; i < bads.length; ++i) {
+          var theGoto = bads[i];
+          raise(theGoto.token, errors.gotoJumpInLocalScope, theGoto.target, scope.locals[theGoto.localCounts[this.scopes.length - 1]].name);
+        }
+      };
+      function LoopFlowContext() {
+        this.level = 0;
+        this.loopLevels = [];
+      }
+      LoopFlowContext.prototype.isInLoop = function() {
+        return !!this.loopLevels.length;
+      };
+      LoopFlowContext.prototype.pushScope = function(isLoop) {
+        ++this.level;
+        if (isLoop)
+          this.loopLevels.push(this.level);
+      };
+      LoopFlowContext.prototype.popScope = function() {
+        var levels = this.loopLevels;
+        var levlen = levels.length;
+        if (levlen) {
+          if (levels[levlen - 1] === this.level)
+            levels.pop();
+        }
+        --this.level;
+      };
+      LoopFlowContext.prototype.addGoto = LoopFlowContext.prototype.addLabel = /* istanbul ignore next */
+      function() {
+        throw new Error("This should never happen");
+      };
+      LoopFlowContext.prototype.addLocal = LoopFlowContext.prototype.raiseDeferredErrors = function() {
+      };
+      function makeFlowContext() {
+        return features.labels ? new FullFlowContext() : new LoopFlowContext();
+      }
+      function parseChunk() {
+        next();
+        markLocation();
+        if (options.scope) createScope();
+        var flowContext = makeFlowContext();
+        flowContext.allowVararg = true;
+        flowContext.pushScope();
+        var body = parseBlock(flowContext);
+        flowContext.popScope();
+        if (options.scope) destroyScope();
+        if (EOF !== token.type) unexpected(token);
+        if (trackLocations && !body.length) previousToken = token;
+        return finishNode(ast.chunk(body));
+      }
+      function parseBlock(flowContext) {
+        var block = [], statement;
+        while (!isBlockFollow(token)) {
+          if ("return" === token.value || !features.relaxedBreak && "break" === token.value) {
+            block.push(parseStatement(flowContext));
+            break;
+          }
+          statement = parseStatement(flowContext);
+          consume(";");
+          if (statement) block.push(statement);
+        }
+        return block;
+      }
+      function parseStatement(flowContext) {
+        markLocation();
+        if (Punctuator === token.type) {
+          if (consume("::")) return parseLabelStatement(flowContext);
+        }
+        if (features.emptyStatement) {
+          if (consume(";")) {
+            if (trackLocations) locations.pop();
+            return;
+          }
+        }
+        flowContext.raiseDeferredErrors();
+        if (Keyword === token.type) {
+          switch (token.value) {
+            case "local":
+              next();
+              return parseLocalStatement(flowContext);
+            case "if":
+              next();
+              return parseIfStatement(flowContext);
+            case "return":
+              next();
+              return parseReturnStatement(flowContext);
+            case "function":
+              next();
+              var name = parseFunctionName();
+              return parseFunctionDeclaration(name);
+            case "while":
+              next();
+              return parseWhileStatement(flowContext);
+            case "for":
+              next();
+              return parseForStatement(flowContext);
+            case "repeat":
+              next();
+              return parseRepeatStatement(flowContext);
+            case "break":
+              next();
+              if (!flowContext.isInLoop())
+                raise(token, errors.noLoopToBreak, token.value);
+              return parseBreakStatement();
+            case "do":
+              next();
+              return parseDoStatement(flowContext);
+            case "goto":
+              next();
+              return parseGotoStatement(flowContext);
+          }
+        }
+        if (features.contextualGoto && token.type === Identifier && token.value === "goto" && lookahead.type === Identifier && lookahead.value !== "goto") {
+          next();
+          return parseGotoStatement(flowContext);
+        }
+        if (trackLocations) locations.pop();
+        return parseAssignmentOrCallStatement(flowContext);
+      }
+      function parseLabelStatement(flowContext) {
+        var nameToken = token, label = parseIdentifier();
+        if (options.scope) {
+          scopeIdentifierName("::" + nameToken.value + "::");
+          attachScope(label, true);
+        }
+        expect("::");
+        flowContext.addLabel(nameToken.value, nameToken);
+        return finishNode(ast.labelStatement(label));
+      }
+      function parseBreakStatement() {
+        return finishNode(ast.breakStatement());
+      }
+      function parseGotoStatement(flowContext) {
+        var name = token.value, gotoToken = previousToken, label = parseIdentifier();
+        flowContext.addGoto(name, gotoToken);
+        return finishNode(ast.gotoStatement(label));
+      }
+      function parseDoStatement(flowContext) {
+        if (options.scope) createScope();
+        flowContext.pushScope();
+        var body = parseBlock(flowContext);
+        flowContext.popScope();
+        if (options.scope) destroyScope();
+        expect("end");
+        return finishNode(ast.doStatement(body));
+      }
+      function parseWhileStatement(flowContext) {
+        var condition = parseExpectedExpression(flowContext);
+        expect("do");
+        if (options.scope) createScope();
+        flowContext.pushScope(true);
+        var body = parseBlock(flowContext);
+        flowContext.popScope();
+        if (options.scope) destroyScope();
+        expect("end");
+        return finishNode(ast.whileStatement(condition, body));
+      }
+      function parseRepeatStatement(flowContext) {
+        if (options.scope) createScope();
+        flowContext.pushScope(true);
+        var body = parseBlock(flowContext);
+        expect("until");
+        flowContext.raiseDeferredErrors();
+        var condition = parseExpectedExpression(flowContext);
+        flowContext.popScope();
+        if (options.scope) destroyScope();
+        return finishNode(ast.repeatStatement(condition, body));
+      }
+      function parseReturnStatement(flowContext) {
+        var expressions = [];
+        if ("end" !== token.value) {
+          var expression = parseExpression(flowContext);
+          if (null != expression) expressions.push(expression);
+          while (consume(",")) {
+            expression = parseExpectedExpression(flowContext);
+            expressions.push(expression);
+          }
+          consume(";");
+        }
+        return finishNode(ast.returnStatement(expressions));
+      }
+      function parseIfStatement(flowContext) {
+        var clauses = [], condition, body, marker;
+        if (trackLocations) {
+          marker = locations[locations.length - 1];
+          locations.push(marker);
+        }
+        condition = parseExpectedExpression(flowContext);
+        expect("then");
+        if (options.scope) createScope();
+        flowContext.pushScope();
+        body = parseBlock(flowContext);
+        flowContext.popScope();
+        if (options.scope) destroyScope();
+        clauses.push(finishNode(ast.ifClause(condition, body)));
+        if (trackLocations) marker = createLocationMarker();
+        while (consume("elseif")) {
+          pushLocation(marker);
+          condition = parseExpectedExpression(flowContext);
+          expect("then");
+          if (options.scope) createScope();
+          flowContext.pushScope();
+          body = parseBlock(flowContext);
+          flowContext.popScope();
+          if (options.scope) destroyScope();
+          clauses.push(finishNode(ast.elseifClause(condition, body)));
+          if (trackLocations) marker = createLocationMarker();
+        }
+        if (consume("else")) {
+          if (trackLocations) {
+            marker = new Marker(previousToken);
+            locations.push(marker);
+          }
+          if (options.scope) createScope();
+          flowContext.pushScope();
+          body = parseBlock(flowContext);
+          flowContext.popScope();
+          if (options.scope) destroyScope();
+          clauses.push(finishNode(ast.elseClause(body)));
+        }
+        expect("end");
+        return finishNode(ast.ifStatement(clauses));
+      }
+      function parseForStatement(flowContext) {
+        var variable = parseIdentifier(), body;
+        if (options.scope) {
+          createScope();
+          scopeIdentifier(variable);
+        }
+        if (consume("=")) {
+          var start = parseExpectedExpression(flowContext);
+          expect(",");
+          var end2 = parseExpectedExpression(flowContext);
+          var step = consume(",") ? parseExpectedExpression(flowContext) : null;
+          expect("do");
+          flowContext.pushScope(true);
+          body = parseBlock(flowContext);
+          flowContext.popScope();
+          expect("end");
+          if (options.scope) destroyScope();
+          return finishNode(ast.forNumericStatement(variable, start, end2, step, body));
+        } else {
+          var variables = [variable];
+          while (consume(",")) {
+            variable = parseIdentifier();
+            if (options.scope) scopeIdentifier(variable);
+            variables.push(variable);
+          }
+          expect("in");
+          var iterators = [];
+          do {
+            var expression = parseExpectedExpression(flowContext);
+            iterators.push(expression);
+          } while (consume(","));
+          expect("do");
+          flowContext.pushScope(true);
+          body = parseBlock(flowContext);
+          flowContext.popScope();
+          expect("end");
+          if (options.scope) destroyScope();
+          return finishNode(ast.forGenericStatement(variables, iterators, body));
+        }
+      }
+      function parseLocalStatement(flowContext) {
+        var name, declToken = previousToken;
+        if (Identifier === token.type) {
+          var variables = [], init = [];
+          do {
+            name = parseIdentifier();
+            variables.push(name);
+            flowContext.addLocal(name.name, declToken);
+          } while (consume(","));
+          if (consume("=")) {
+            do {
+              var expression = parseExpectedExpression(flowContext);
+              init.push(expression);
+            } while (consume(","));
+          }
+          if (options.scope) {
+            for (var i = 0, l = variables.length; i < l; ++i) {
+              scopeIdentifier(variables[i]);
+            }
+          }
+          return finishNode(ast.localStatement(variables, init));
+        }
+        if (consume("function")) {
+          name = parseIdentifier();
+          flowContext.addLocal(name.name, declToken);
+          if (options.scope) {
+            scopeIdentifier(name);
+            createScope();
+          }
+          return parseFunctionDeclaration(name, true);
+        } else {
+          raiseUnexpectedToken("<name>", token);
+        }
+      }
+      function parseAssignmentOrCallStatement(flowContext) {
+        var previous = token, marker, startMarker;
+        var lvalue, base, name;
+        var targets = [];
+        if (trackLocations) startMarker = createLocationMarker();
+        do {
+          if (trackLocations) marker = createLocationMarker();
+          if (Identifier === token.type) {
+            name = token.value;
+            base = parseIdentifier();
+            if (options.scope) attachScope(base, scopeHasName(name));
+            lvalue = true;
+          } else if ("(" === token.value) {
+            next();
+            base = parseExpectedExpression(flowContext);
+            expect(")");
+            lvalue = false;
+          } else {
+            return unexpected(token);
+          }
+          both: for (; ; ) {
+            var newBase;
+            switch (StringLiteral === token.type ? '"' : token.value) {
+              case ".":
+              case "[":
+                lvalue = true;
+                break;
+              case ":":
+              case "(":
+              case "{":
+              case '"':
+                lvalue = null;
+                break;
+              default:
+                break both;
+            }
+            base = parsePrefixExpressionPart(base, marker, flowContext);
+          }
+          targets.push(base);
+          if ("," !== token.value)
+            break;
+          if (!lvalue) {
+            return unexpected(token);
+          }
+          next();
+        } while (true);
+        if (targets.length === 1 && lvalue === null) {
+          pushLocation(marker);
+          return finishNode(ast.callStatement(targets[0]));
+        } else if (!lvalue) {
+          return unexpected(token);
+        }
+        expect("=");
+        var values = [];
+        do {
+          values.push(parseExpectedExpression(flowContext));
+        } while (consume(","));
+        pushLocation(startMarker);
+        return finishNode(ast.assignmentStatement(targets, values));
+      }
+      function parseIdentifier() {
+        markLocation();
+        var identifier = token.value;
+        if (Identifier !== token.type) raiseUnexpectedToken("<name>", token);
+        next();
+        return finishNode(ast.identifier(identifier));
+      }
+      function parseFunctionDeclaration(name, isLocal) {
+        var flowContext = makeFlowContext();
+        flowContext.pushScope();
+        var parameters = [];
+        expect("(");
+        if (!consume(")")) {
+          while (true) {
+            if (Identifier === token.type) {
+              var parameter = parseIdentifier();
+              if (options.scope) scopeIdentifier(parameter);
+              parameters.push(parameter);
+              if (consume(",")) continue;
+            } else if (VarargLiteral === token.type) {
+              flowContext.allowVararg = true;
+              parameters.push(parsePrimaryExpression(flowContext));
+            } else {
+              raiseUnexpectedToken("<name> or '...'", token);
+            }
+            expect(")");
+            break;
+          }
+        }
+        var body = parseBlock(flowContext);
+        flowContext.popScope();
+        expect("end");
+        if (options.scope) destroyScope();
+        isLocal = isLocal || false;
+        return finishNode(ast.functionStatement(name, parameters, isLocal, body));
+      }
+      function parseFunctionName() {
+        var base, name, marker;
+        if (trackLocations) marker = createLocationMarker();
+        base = parseIdentifier();
+        if (options.scope) {
+          attachScope(base, scopeHasName(base.name));
+          createScope();
+        }
+        while (consume(".")) {
+          pushLocation(marker);
+          name = parseIdentifier();
+          base = finishNode(ast.memberExpression(base, ".", name));
+        }
+        if (consume(":")) {
+          pushLocation(marker);
+          name = parseIdentifier();
+          base = finishNode(ast.memberExpression(base, ":", name));
+          if (options.scope) scopeIdentifierName("self");
+        }
+        return base;
+      }
+      function parseTableConstructor(flowContext) {
+        var fields = [], key, value;
+        while (true) {
+          markLocation();
+          if (Punctuator === token.type && consume("[")) {
+            key = parseExpectedExpression(flowContext);
+            expect("]");
+            expect("=");
+            value = parseExpectedExpression(flowContext);
+            fields.push(finishNode(ast.tableKey(key, value)));
+          } else if (Identifier === token.type) {
+            if ("=" === lookahead.value) {
+              key = parseIdentifier();
+              next();
+              value = parseExpectedExpression(flowContext);
+              fields.push(finishNode(ast.tableKeyString(key, value)));
+            } else {
+              value = parseExpectedExpression(flowContext);
+              fields.push(finishNode(ast.tableValue(value)));
+            }
+          } else {
+            if (null == (value = parseExpression(flowContext))) {
+              locations.pop();
+              break;
+            }
+            fields.push(finishNode(ast.tableValue(value)));
+          }
+          if (",;".indexOf(token.value) >= 0) {
+            next();
+            continue;
+          }
+          break;
+        }
+        expect("}");
+        return finishNode(ast.tableConstructorExpression(fields));
+      }
+      function parseExpression(flowContext) {
+        var expression = parseSubExpression(0, flowContext);
+        return expression;
+      }
+      function parseExpectedExpression(flowContext) {
+        var expression = parseExpression(flowContext);
+        if (null == expression) raiseUnexpectedToken("<expression>", token);
+        else return expression;
+      }
+      function binaryPrecedence(operator) {
+        var charCode = operator.charCodeAt(0), length2 = operator.length;
+        if (1 === length2) {
+          switch (charCode) {
+            case 94:
+              return 12;
+            // ^
+            case 42:
+            case 47:
+            case 37:
+              return 10;
+            // * / %
+            case 43:
+            case 45:
+              return 9;
+            // + -
+            case 38:
+              return 6;
+            // &
+            case 126:
+              return 5;
+            // ~
+            case 124:
+              return 4;
+            // |
+            case 60:
+            case 62:
+              return 3;
+          }
+        } else if (2 === length2) {
+          switch (charCode) {
+            case 47:
+              return 10;
+            // //
+            case 46:
+              return 8;
+            // ..
+            case 60:
+            case 62:
+              if ("<<" === operator || ">>" === operator) return 7;
+              return 3;
+            // <= >=
+            case 61:
+            case 126:
+              return 3;
+            // == ~=
+            case 111:
+              return 1;
+          }
+        } else if (97 === charCode && "and" === operator) return 2;
+        return 0;
+      }
+      function parseSubExpression(minPrecedence, flowContext) {
+        var operator = token.value, expression, marker;
+        if (trackLocations) marker = createLocationMarker();
+        if (isUnary(token)) {
+          markLocation();
+          next();
+          var argument = parseSubExpression(10, flowContext);
+          if (argument == null) raiseUnexpectedToken("<expression>", token);
+          expression = finishNode(ast.unaryExpression(operator, argument));
+        }
+        if (null == expression) {
+          expression = parsePrimaryExpression(flowContext);
+          if (null == expression) {
+            expression = parsePrefixExpression(flowContext);
+          }
+        }
+        if (null == expression) return null;
+        var precedence;
+        while (true) {
+          operator = token.value;
+          precedence = Punctuator === token.type || Keyword === token.type ? binaryPrecedence(operator) : 0;
+          if (precedence === 0 || precedence <= minPrecedence) break;
+          if ("^" === operator || ".." === operator) --precedence;
+          next();
+          var right = parseSubExpression(precedence, flowContext);
+          if (null == right) raiseUnexpectedToken("<expression>", token);
+          if (trackLocations) locations.push(marker);
+          expression = finishNode(ast.binaryExpression(operator, expression, right));
+        }
+        return expression;
+      }
+      function parsePrefixExpressionPart(base, marker, flowContext) {
+        var expression, identifier;
+        if (Punctuator === token.type) {
+          switch (token.value) {
+            case "[":
+              pushLocation(marker);
+              next();
+              expression = parseExpectedExpression(flowContext);
+              expect("]");
+              return finishNode(ast.indexExpression(base, expression));
+            case ".":
+              pushLocation(marker);
+              next();
+              identifier = parseIdentifier();
+              return finishNode(ast.memberExpression(base, ".", identifier));
+            case ":":
+              pushLocation(marker);
+              next();
+              identifier = parseIdentifier();
+              base = finishNode(ast.memberExpression(base, ":", identifier));
+              pushLocation(marker);
+              return parseCallExpression(base, flowContext);
+            case "(":
+            case "{":
+              pushLocation(marker);
+              return parseCallExpression(base, flowContext);
+          }
+        } else if (StringLiteral === token.type) {
+          pushLocation(marker);
+          return parseCallExpression(base, flowContext);
+        }
+        return null;
+      }
+      function parsePrefixExpression(flowContext) {
+        var base, name, marker;
+        if (trackLocations) marker = createLocationMarker();
+        if (Identifier === token.type) {
+          name = token.value;
+          base = parseIdentifier();
+          if (options.scope) attachScope(base, scopeHasName(name));
+        } else if (consume("(")) {
+          base = parseExpectedExpression(flowContext);
+          expect(")");
+        } else {
+          return null;
+        }
+        for (; ; ) {
+          var newBase = parsePrefixExpressionPart(base, marker, flowContext);
+          if (newBase === null)
+            break;
+          base = newBase;
+        }
+        return base;
+      }
+      function parseCallExpression(base, flowContext) {
+        if (Punctuator === token.type) {
+          switch (token.value) {
+            case "(":
+              if (!features.emptyStatement) {
+                if (token.line !== previousToken.line)
+                  raise(null, errors.ambiguousSyntax, token.value);
+              }
+              next();
+              var expressions = [];
+              var expression = parseExpression(flowContext);
+              if (null != expression) expressions.push(expression);
+              while (consume(",")) {
+                expression = parseExpectedExpression(flowContext);
+                expressions.push(expression);
+              }
+              expect(")");
+              return finishNode(ast.callExpression(base, expressions));
+            case "{":
+              markLocation();
+              next();
+              var table = parseTableConstructor(flowContext);
+              return finishNode(ast.tableCallExpression(base, table));
+          }
+        } else if (StringLiteral === token.type) {
+          return finishNode(ast.stringCallExpression(base, parsePrimaryExpression(flowContext)));
+        }
+        raiseUnexpectedToken("function arguments", token);
+      }
+      function parsePrimaryExpression(flowContext) {
+        var literals = StringLiteral | NumericLiteral | BooleanLiteral | NilLiteral | VarargLiteral, value = token.value, type = token.type, marker;
+        if (trackLocations) marker = createLocationMarker();
+        if (type === VarargLiteral && !flowContext.allowVararg) {
+          raise(token, errors.cannotUseVararg, token.value);
+        }
+        if (type & literals) {
+          pushLocation(marker);
+          var raw = input.slice(token.range[0], token.range[1]);
+          next();
+          return finishNode(ast.literal(type, value, raw));
+        } else if (Keyword === type && "function" === value) {
+          pushLocation(marker);
+          next();
+          if (options.scope) createScope();
+          return parseFunctionDeclaration(null);
+        } else if (consume("{")) {
+          pushLocation(marker);
+          return parseTableConstructor(flowContext);
+        }
+      }
+      exports2.parse = parse2;
+      var versionFeatures = {
+        "5.1": {},
+        "5.2": {
+          labels: true,
+          emptyStatement: true,
+          hexEscapes: true,
+          skipWhitespaceEscape: true,
+          strictEscapes: true,
+          relaxedBreak: true
+        },
+        "5.3": {
+          labels: true,
+          emptyStatement: true,
+          hexEscapes: true,
+          skipWhitespaceEscape: true,
+          strictEscapes: true,
+          unicodeEscapes: true,
+          bitwiseOperators: true,
+          integerDivision: true,
+          relaxedBreak: true
+        },
+        "LuaJIT": {
+          // XXX: LuaJIT language features may depend on compilation options; may need to
+          // rethink how to handle this. Specifically, there is a LUAJIT_ENABLE_LUA52COMPAT
+          // that removes contextual goto. Maybe add 'LuaJIT-5.2compat' as well?
+          labels: true,
+          contextualGoto: true,
+          hexEscapes: true,
+          skipWhitespaceEscape: true,
+          strictEscapes: true,
+          unicodeEscapes: true,
+          imaginaryNumbers: true,
+          integerSuffixes: true
+        }
+      };
+      function parse2(_input, _options) {
+        if ("undefined" === typeof _options && "object" === typeof _input) {
+          _options = _input;
+          _input = void 0;
+        }
+        if (!_options) _options = {};
+        input = _input || "";
+        options = assign({}, defaultOptions, _options);
+        index = 0;
+        line = 1;
+        lineStart = 0;
+        length = input.length;
+        scopes = [[]];
+        scopeDepth = 0;
+        globals = [];
+        locations = [];
+        if (!Object.prototype.hasOwnProperty.call(versionFeatures, options.luaVersion)) {
+          throw new Error(sprintf("Lua version '%1' not supported", options.luaVersion));
+        }
+        features = assign({}, versionFeatures[options.luaVersion]);
+        if (options.extendedIdentifiers !== void 0)
+          features.extendedIdentifiers = !!options.extendedIdentifiers;
+        if (!Object.prototype.hasOwnProperty.call(encodingModes, options.encodingMode)) {
+          throw new Error(sprintf("Encoding mode '%1' not supported", options.encodingMode));
+        }
+        encodingMode = encodingModes[options.encodingMode];
+        if (options.comments) comments = [];
+        if (!options.wait) return end();
+        return exports2;
+      }
+      exports2.write = write;
+      function write(_input) {
+        input += String(_input);
+        length = input.length;
+        return exports2;
+      }
+      exports2.end = end;
+      function end(_input) {
+        if ("undefined" !== typeof _input) write(_input);
+        if (input && input.substr(0, 2) === "#!") input = input.replace(/^.*/, function(line2) {
+          return line2.replace(/./g, " ");
+        });
+        length = input.length;
+        trackLocations = options.locations || options.ranges;
+        lookahead = lex();
+        var chunk = parseChunk();
+        if (options.comments) chunk.comments = comments;
+        if (options.scope) chunk.globals = globals;
+        if (locations.length > 0)
+          throw new Error("Location tracking failed. This is most likely a bug in luaparse");
+        return chunk;
+      }
+    });
+  }
+});
+
+// Classify/barrel.nodejs.ts
+var barrel_nodejs_exports = {};
+__export(barrel_nodejs_exports, {
+  Asks: () => Asks2,
+  AsksWhen: () => AsksWhen,
+  AsksWhen_: () => AsksWhen_,
+  Bind: () => Bind4,
+  BindOption: () => BindOption,
+  BindOption_: () => BindOption_,
+  Bind_: () => Bind_4,
+  Catch: () => Catch2,
+  Catch_: () => Catch_2,
+  Extensions: () => Extensions,
+  Map: () => Map6,
+  Map_: () => Map_5,
+  None: () => None2,
+  Pure: () => Pure2,
+  SetWhen: () => SetWhen,
+  SetWhen_: () => SetWhen_
+});
+
+// Lib/Array/Array.pure.ts
+var Array_pure_exports = {};
+__export(Array_pure_exports, {
+  Bind: () => Bind2,
+  Bind_: () => Bind_2,
+  Choose: () => Choose,
+  Choose_: () => Choose_,
+  Filter: () => Filter,
+  Filter_: () => Filter_,
+  IsNonEmpty: () => IsNonEmpty,
+  Map: () => Map3,
+  Map_: () => Map_2
+});
+
+// Lib/Function/Curry.pure.ts
+var CurryRev = (body) => (
+  // @ts-expect-error
+  (...args1) => {
+    if (args1.length >= body.length)
+      return body(...args1);
+    else
+      return (...args2) => body(...args2.slice(0, Math.max(0, body.length - args1.length)), ...args1);
+  }
+);
+
+// Lib/Function/Flow.pure.ts
+function Flow(ab, bc, cd, de, ef, fg, gh, hi, ij) {
+  switch (arguments.length) {
+    case 1:
+      return ab;
+    case 2:
+      return function() {
+        return bc(ab.apply(this, arguments));
+      };
+    case 3:
+      return function() {
+        return cd(bc(ab.apply(this, arguments)));
+      };
+    case 4:
+      return function() {
+        return de(cd(bc(ab.apply(this, arguments))));
+      };
+    case 5:
+      return function() {
+        return ef(de(cd(bc(ab.apply(this, arguments)))));
+      };
+    case 6:
+      return function() {
+        return fg(ef(de(cd(bc(ab.apply(this, arguments))))));
+      };
+    case 7:
+      return function() {
+        return gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))));
+      };
+    case 8:
+      return function() {
+        return hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments))))))));
+      };
+    case 9:
+      return function() {
+        return ij(hi(gh(fg(ef(de(cd(bc(ab.apply(this, arguments)))))))));
+      };
+  }
+  return;
+}
+
+// Lib/Function/Pipe.pure.ts
+function Pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+  switch (arguments.length) {
+    case 1:
+      return a;
+    case 2:
+      return ab(a);
+    case 3:
+      return bc(ab(a));
+    case 4:
+      return cd(bc(ab(a)));
+    case 5:
+      return de(cd(bc(ab(a))));
+    case 6:
+      return ef(de(cd(bc(ab(a)))));
+    case 7:
+      return fg(ef(de(cd(bc(ab(a))))));
+    case 8:
+      return gh(fg(ef(de(cd(bc(ab(a)))))));
+    case 9:
+      return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+    default: {
+      let ret = arguments[0];
+      for (let i = 1; i < arguments.length; i++) {
+        ret = arguments[i](ret);
+      }
+      return ret;
+    }
+  }
+}
+
+// Lib/Option/Option.pure.ts
+var Option_pure_exports = {};
+__export(Option_pure_exports, {
+  All: () => All,
+  Bind: () => Bind,
+  Bind_: () => Bind_,
+  Catch: () => Catch,
+  Catch_: () => Catch_,
+  Default: () => Default,
+  DefaultLazy: () => DefaultLazy,
+  DefaultLazy_: () => DefaultLazy_,
+  Default_: () => Default_,
+  Elim: () => Elim,
+  ElimLazy: () => ElimLazy,
+  ElimLazy_: () => ElimLazy_,
+  Elim_: () => Elim_,
+  IsNone: () => IsNone,
+  IsSome: () => IsSome,
+  Map: () => Map2,
+  Map_: () => Map_,
+  Match: () => Match,
+  Match_: () => Match_,
+  None: () => None,
+  OfNullable: () => OfNullable,
+  Some: () => Some,
+  Some_Filter: () => Some_Filter,
+  Some_Filter_: () => Some_Filter_
+});
+var Some = (value) => ({
+  _tag: "Some",
+  value
+});
+var none = { _tag: "None" };
+var None = () => none;
+var OfNullable = (value) => value === null || value === void 0 ? none : Some(value);
+var Some_Filter_ = (a, pred) => pred(a) ? Some(a) : None();
+var Some_Filter = CurryRev(Some_Filter_);
+var IsSome = (opt) => opt._tag === "Some";
+var IsNone = (opt) => opt._tag === "None";
+var All = (os) => {
+  const out = [];
+  for (const o of os) {
+    if (IsNone(o)) return None();
+    out.push(o.value);
+  }
+  return Some(out);
+};
+var Bind_ = (opt, f) => IsSome(opt) ? f(opt.value) : none;
+var Bind = CurryRev(Bind_);
+var Map_ = (opt, f) => IsSome(opt) ? Some(f(opt.value)) : none;
+var Map2 = CurryRev(Map_);
+var Catch_ = (opt, f) => IsSome(opt) ? opt : f();
+var Catch = CurryRev(Catch_);
+var Default_ = (opt, fallback) => IsSome(opt) ? opt.value : fallback;
+var Default = CurryRev(Default_);
+var DefaultLazy_ = (opt, fallback) => IsSome(opt) ? opt.value : fallback();
+var DefaultLazy = CurryRev(DefaultLazy_);
+var Elim_ = (opt, fallback, f) => Pipe(Map_(opt, f), (o) => Default_(o, fallback));
+var Elim = CurryRev(Elim_);
+var ElimLazy_ = (opt, fallback, f) => Pipe(Map2(opt, f), DefaultLazy(fallback));
+var ElimLazy = CurryRev(ElimLazy_);
+var Match_ = (opt, handlers) => IsSome(opt) ? handlers.onSome(opt.value) : handlers.onNone();
+var Match = CurryRev(Match_);
+
+// Lib/Array/Array.pure.ts
+var IsNonEmpty = ((xs) => xs.length > 0);
+var Bind_2 = (f) => (xs) => xs.flatMap(f);
+var Bind2 = CurryRev(Bind_2);
+var Choose_ = (xs, chooser) => {
+  const out = [];
+  for (let i = 0; i < xs.length; i++) {
+    const y = chooser(xs[i], i);
+    if (Option_pure_exports.IsSome(y)) out.push(y.value);
+  }
+  return out;
+};
+var Choose = CurryRev(Choose_);
+var Filter_ = (xs, pred) => {
+  const out = [];
+  for (let i = 0; i < xs.length; i++) {
+    const x = xs[i];
+    if (pred(x, i)) out.push(x);
+  }
+  return out;
+};
+var Filter = CurryRev(Filter_);
+var Map_2 = (xs, f) => xs.map(f);
+var Map3 = CurryRev(Map_2);
+
+// Lib/Reader/Reader.pure.ts
+var Reader_pure_exports = {};
+__export(Reader_pure_exports, {
+  Asks: () => Asks,
+  Bind: () => Bind3,
+  Bind_: () => Bind_3,
+  Map: () => Map4,
+  Map_: () => Map_3,
+  Pure: () => Pure
+});
+var Pure = (a) => (_env) => a;
+var Map_3 = (m, f) => (env) => f(m(env));
+var Map4 = CurryRev(Map_3);
+var Bind_3 = (m, f) => (env) => f(m(env))(env);
+var Bind3 = CurryRev(Bind_3);
+var Asks = (f) => (env) => f(env);
+
+// Lib/Result/Result.pure.ts
+var Result_pure_exports = {};
+__export(Result_pure_exports, {
+  Error: () => Error2,
+  GetOrThrow: () => GetOrThrow,
+  IsError: () => IsError,
+  IsOk: () => IsOk,
+  Map: () => Map5,
+  Map_: () => Map_4,
+  Ok: () => Ok
+});
+var Ok = (value) => ({
+  _tag: "Ok",
+  value
+});
+var Error2 = (reason) => ({
+  _tag: "Error",
+  error: reason
+});
+var IsOk = (res) => res._tag === "Ok";
+var IsError = (res) => res._tag === "Error";
+var Map_4 = (res, f) => IsOk(res) ? Ok(f(res.value)) : res;
+var Map5 = CurryRev(Map_4);
+var GetOrThrow = (res) => {
+  if (IsOk(res))
+    return res.value;
+  else
+    throw new globalThis.Error(JSON.stringify(res.error));
+};
+
+// Lib/Set/Set.pure.ts
+var Set_pure_exports = {};
+__export(Set_pure_exports, {
+  Empty: () => Empty,
+  Empty_Mut: () => Empty_Mut,
+  FromIterable: () => FromIterable,
+  Has: () => Has,
+  Singleton: () => Singleton,
+  ToArray: () => ToArray,
+  ToMutable: () => ToMutable
+});
+var _empty = new globalThis.Set();
+var Empty = () => _empty;
+var Empty_Mut = () => new globalThis.Set();
+var Singleton = (x) => new globalThis.Set([x]);
+var FromIterable = (xs) => new globalThis.Set(xs);
+var ToArray = (set) => [...set];
+var ToMutable = (set) => new globalThis.Set(set);
+var Has = (xs, y) => xs.has(y);
+
+// Classify/Classify.pure.ts
+var Pure2 = (a) => (_) => Option_pure_exports.Some(a);
+var None2 = () => (_) => Option_pure_exports.None();
+var Map_5 = (m, f) => Reader_pure_exports.Map_(m, (m2) => Option_pure_exports.Map_(m2, f));
+var Map6 = CurryRev(Map_5);
+var Bind_4 = (m, f) => (ext) => Option_pure_exports.Bind(m(ext), (t) => f(t)(ext));
+var Bind4 = CurryRev(Bind_4);
+var BindOption_ = (m, f) => Reader_pure_exports.Map_(m, (m2) => Option_pure_exports.Bind_(m2, f));
+var BindOption = CurryRev(BindOption_);
+var Asks2 = (f) => (ext) => Option_pure_exports.Some(f(ext));
+var Catch_2 = (m1, m2) => (ext) => Option_pure_exports.Catch_(m1(ext), () => m2(ext));
+var Catch2 = CurryRev(Catch_2);
+var AsksWhen_ = (p, m) => Reader_pure_exports.Bind_(Reader_pure_exports.Asks(p), (b) => b ? m : None2());
+var AsksWhen = CurryRev(AsksWhen_);
+var SetWhen_ = (p, f) => AsksWhen_(p, Flow(f, Option_pure_exports.Some));
+var SetWhen = CurryRev(SetWhen_);
+
+// Classify/File.nodejs.ts
+import path from "node:path";
+var Extensions = (extIter) => {
+  const exts = Set_pure_exports.FromIterable(extIter);
+  if (exts.values().some((x) => x.includes("."))) {
+    throw new Error("File extensions may not contain a '.' character. Pass multiple extensions instead.");
+  }
+  return (filepath) => Pipe(
+    path.basename(filepath).split("."),
+    Array_pure_exports.Filter((x) => Set_pure_exports.Has(exts, x)),
+    (x) => x.join("."),
+    Option_pure_exports.Some_Filter((x) => x.length > 0)
+  );
+};
+
+// Checker/Checker.pure.ts
+var Checker_pure_exports = {};
+__export(Checker_pure_exports, {
+  Allow: () => Allow2,
+  Ask: () => Ask,
+  Asks: () => Asks3,
+  AsksWhen: () => AsksWhen2,
+  AsksWhen_: () => AsksWhen_2,
+  Bind: () => Bind6,
+  Bind_: () => Bind_5,
+  Build: () => Build,
+  Deny: () => Deny2,
+  IfM: () => IfM,
+  IfM_: () => IfM_,
+  Map: () => Map8,
+  Map_: () => Map_6,
+  Opinion: () => Opinion_pure_exports,
+  Pure: () => Pure4,
+  Then: () => Then,
+  Then_: () => Then_,
+  Validate: () => Validate,
+  Warn: () => Warn2,
+  When: () => When,
+  When_: () => When_
+});
+
+// Checker/Opinion/Opinion.pure.ts
+var Opinion_pure_exports = {};
+__export(Opinion_pure_exports, {
+  Allow: () => Allow,
+  Bind: () => Bind5,
+  Deny: () => Deny,
+  Map: () => Map7,
+  Pure: () => Pure3,
+  Warn: () => Warn
+});
+var Pure3 = (a) => ({ _tag: "Pure", Value: a });
+var Allow = () => ({ _tag: "Allow" });
+var Deny = (d) => ({ _tag: "Deny", Deps: d });
+var Warn = (x) => ({ _tag: "Warn", Message: x });
+var Map7 = (m, f) => m._tag === "Pure" ? Pure3(f(m.Value)) : m;
+var Bind5 = (m, f) => m._tag === "Pure" ? f(m.Value) : m;
+
+// Partial_Order/PartialOrder.pure.ts
+var PartialOrder_pure_exports = {};
+__export(PartialOrder_pure_exports, {
+  Make: () => Make,
+  Query: () => Query
+});
+var invert = (rel) => rel === "<" ? ">" : "<";
+var Make = (chains) => {
+  const po = /* @__PURE__ */ new Map();
+  let cyclic = false;
+  const getRels = (x) => {
+    if (!po.has(x)) po.set(x, /* @__PURE__ */ new Map());
+    return po.get(x);
+  };
+  const addRel = (x, rel, y) => {
+    const xRels = getRels(x);
+    if (xRels.get(y) === invert(rel)) {
+      cyclic = true;
+    } else {
+      xRels.set(y, rel);
+    }
+  };
+  const addRelSym = (x, _rel, y) => {
+    addRel(x, "<", y);
+    addRel(y, ">", x);
+  };
+  for (const chain of chains) {
+    if (chain.length === 0) continue;
+    const head = chain[0];
+    const tail = chain.slice(1);
+    let xs = Array.isArray(head) ? head : [head];
+    for (const l of tail) {
+      const ys = Array.isArray(l) ? l : [l];
+      for (const x of xs) {
+        for (const y of ys) {
+          addRelSym(x, "<", y);
+          getRels(x).forEach((rel, w) => {
+            if (rel === ">") addRelSym(w, "<", y);
+          });
+          getRels(y).forEach((rel, z) => {
+            if (rel === "<") addRelSym(x, "<", z);
+          });
+        }
+      }
+      xs = ys;
+    }
+  }
+  return cyclic ? Result_pure_exports.Error("Partial order rules induce a cycle") : Result_pure_exports.Ok(po);
+};
+var Query = (po, x, y) => x === y ? "=" : po.get(x)?.get(y) ?? "?";
+
+// Checker/Checker.pure.ts
+var Pure4 = (val) => Reader_pure_exports.Pure(Opinion_pure_exports.Pure(val));
+var Allow2 = () => Reader_pure_exports.Pure(Opinion_pure_exports.Allow());
+var Deny2 = () => Reader_pure_exports.Asks(Opinion_pure_exports.Deny);
+var Warn2 = (x) => Reader_pure_exports.Pure(Opinion_pure_exports.Warn(x));
+var Bind_5 = (m, f) => (d) => Opinion_pure_exports.Bind(m(d), (t) => f(t)(d));
+var Bind6 = CurryRev(Bind_5);
+var Map_6 = (m, f) => Bind_5(m, Flow(f, Pure4));
+var Map8 = CurryRev(Map_6);
+var Asks3 = (f) => Reader_pure_exports.Asks(Flow(f, Opinion_pure_exports.Pure));
+var Ask = Asks3((d) => d);
+var Then_ = (m1, m2) => Bind_5(m1, (_) => m2);
+var Then = CurryRev(Then_);
+var When_ = (b, m) => b ? m : Pure4(void 0);
+var When = CurryRev(When_);
+var AsksWhen_2 = (p, m) => Bind_5(Asks3(p), When(m));
+var AsksWhen2 = CurryRev(AsksWhen_2);
+var IfM_ = (mp, m1, m2) => Bind_5(mp, (b) => b ? m1 : m2);
+var IfM = CurryRev(IfM_);
+var Build = (classify) => (partialOrder) => build(classify, Result_pure_exports.GetOrThrow(partialOrder));
+var build = (classify, po) => ([xPath, yPath]) => Pipe(
+  Option_pure_exports.All([classify(xPath), classify(yPath)]),
+  Option_pure_exports.Elim(
+    Opinion_pure_exports.Pure(void 0),
+    ([xClass, yClass]) => {
+      switch (PartialOrder_pure_exports.Query(po, xClass, yClass)) {
+        case "<":
+        case "=":
+          return Opinion_pure_exports.Allow();
+        case ">":
+        case "?":
+          return Opinion_pure_exports.Deny([xPath, yPath]);
+      }
+    }
+  )
+);
+var Validate = (check, deps) => {
+  const out = { deny: [], warn: [] };
+  deps.forEach((x) => {
+    const opinion = check(x);
+    switch (opinion._tag) {
+      case "Pure":
+        return out.warn.push(`unhandled dependency: [${x[0]} -> ${x[1]}]`);
+      case "Allow":
+        return;
+      case "Deny":
+        return out.deny.push(x);
+      case "Warn":
+        return out.warn.push(opinion.Message);
+      default:
+        opinion;
+    }
+  });
+  return out;
+};
+
+// Plugin/barrel.nodejs.ts
+var barrel_nodejs_exports2 = {};
+__export(barrel_nodejs_exports2, {
+  Esbuild: () => Esbuild,
+  Lua: () => Lua_nodejs_exports
+});
+
+// Plugin/esbuild.nodejs.ts
+var Esbuild = (check) => ({
+  name: "purity-seal",
+  setup: (build2) => {
+    build2.initialOptions.metafile = true;
+    build2.onEnd((buildResult) => {
+      if (buildResult.metafile === void 0) return {};
+      const inputs = buildResult.metafile.inputs;
+      const warnings = [];
+      const warn = (dependent, dependency, message) => warnings.push({
+        text: message,
+        notes: [
+          { text: `Dependent: ${dependent}` },
+          { text: `Dependency: ${dependency}` }
+        ]
+      });
+      const errors = [];
+      const error = (dependent, dependency, message) => errors.push({
+        text: message,
+        notes: [
+          { text: `Dependent: ${dependent}` },
+          { text: `Dependency: ${dependency}` }
+        ]
+      });
+      for (const dependent in inputs) {
+        for (const { path: dependency } of inputs[dependent].imports) {
+          const result = check([dependent, dependency]);
+          switch (result._tag) {
+            case "Pure":
+              warn(dependent, dependency, "unhandled dependency");
+              break;
+            case "Allow":
+              break;
+            case "Warn":
+              warn(dependent, dependency, result.Message);
+              break;
+            case "Deny":
+              const reason = `Deny: ${result.Deps[0]} depends on ${result.Deps[1]}`;
+              error(dependent, dependency, reason);
+              break;
+            default:
+              result;
+          }
+        }
+      }
+      return { warnings, errors };
+    });
+  }
+});
+
+// Plugin/Lua.nodejs.ts
+var Lua_nodejs_exports = {};
+__export(Lua_nodejs_exports, {
+  BuildDeps: () => BuildDeps
+});
+var Parser = __toESM(require_luaparse(), 1);
+import Fs from "node:fs/promises";
+var BuildDeps = async (filenames, bag) => {
+  const opened = /* @__PURE__ */ new Set();
+  const rec = async (filename) => {
+    if (opened.has(filename)) return [];
+    else {
+      opened.add(filename);
+      const filepath = bag.resolveModule(filename);
+      const contents = await readFileContents(filepath);
+      const imports = parseImports(contents, bag);
+      const deps2 = imports.map((x) => [
+        filepath,
+        bag.resolveModule(x)
+      ]);
+      const depsRec = await Promise.all(imports.map(rec));
+      return deps2.concat(depsRec.flat());
+    }
+  };
+  const deps = [];
+  for (const filename of filenames) {
+    deps.push(...await rec(filename));
+  }
+  return deps;
+};
+var readFileContents = async (filename) => {
+  const file = await Fs.open(filename);
+  const lines = [];
+  for await (const line of file.readLines()) {
+    lines.push(line);
+  }
+  await file.close();
+  return lines.join("\n");
+};
+var parseImports = (text, bag) => Pipe(
+  Parser.parse(text, bag).body,
+  Array_pure_exports.Filter((x) => x.type === "LocalStatement"),
+  Array_pure_exports.Bind(traverse_imports_after_assignment),
+  Array_pure_exports.Map((x) => x.slice(1, -1))
+  // luaparse wraps strings in double quotes
+);
+var traverse_imports_after_assignment = (n) => Array_pure_exports.Choose(n.init, (x) => {
+  if (x.type === "StringCallExpression")
+    return Option_pure_exports.Some(x.argument.raw);
+  else if (x.type === "CallExpression" && x.base.type === "Identifier" && x.base.name === "require" && Array_pure_exports.IsNonEmpty(x.arguments) && x.arguments[0].type === "StringLiteral")
+    return Option_pure_exports.Some(x.arguments[0].raw);
+  else
+    return Option_pure_exports.None();
+});
+export {
+  Array_pure_exports as Array,
+  Checker_pure_exports as Checker,
+  barrel_nodejs_exports as Classify,
+  CurryRev,
+  Flow,
+  Option_pure_exports as Option,
+  PartialOrder_pure_exports as PartialOrder,
+  Pipe,
+  barrel_nodejs_exports2 as Plugin,
+  Reader_pure_exports as Reader,
+  Result_pure_exports as Result,
+  Set_pure_exports as Set
+};