astexplorer.app/vendor/astexplorer/out/64.js

https://astexplorer.net with ES Modules support and Hot Reloading

(window.webpackJsonp=window.webpackJsonp||[]).push([[64,101],{"./node_modules/halting-problem/index.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nmodule.exports = __webpack_require__("./node_modules/halting-problem/lib/halting-problem.js");\nmodule.exports.loopProtect = __webpack_require__("./node_modules/halting-problem/lib/loop-protect.js");\nmodule.exports.reset = __webpack_require__("./node_modules/halting-problem/lib/runtime.js").reset;\nmodule.exports.protect = __webpack_require__("./node_modules/halting-problem/lib/runtime.js").protect;\n\n//# sourceURL=webpack:///./node_modules/halting-problem/index.js?')},"./node_modules/halting-problem/lib/halting-problem.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nvar acorn = __webpack_require__("./node_modules/halting-problem/node_modules/acorn/dist/acorn.mjs");\nvar walk = __webpack_require__("./node_modules/halting-problem/node_modules/acorn-walk/dist/walk.mjs");\n\nmodule.exports = halts;\nfunction halts(src) {\n  var ast = typeof src === \'string\' ? acorn.parse(src, {\n    ecmaVersion: 2020,\n    allowReturnOutsideFunction: true,\n    allowImportExportEverywhere: true,\n    allowHashBang: true,\n    locations: true\n  }) : src;\n  var hasBreak = false;\n  var hasThrow = false;\n  var hasReturnOrYield = false;\n  var writeHandlers = [];\n  var readHandlers = [];\n  var callHandlers = [];\n  var breakLabels = [];\n  function watch(fn) {\n    var writes = [];\n    var reads = [];\n    var calls = [];\n    writeHandlers.push(writes);\n    readHandlers.push(reads);\n    callHandlers.push(calls);\n    fn();\n    writeHandlers.pop();\n    readHandlers.pop();\n    callHandlers.pop();\n    return {writes: writes, reads: reads, calls: calls};\n  }\n  function onWrite(name) {\n    writeHandlers.forEach(function (handler) { handler.push(name); });\n  }\n  function onRead(name) {\n    readHandlers.forEach(function (handler) { handler.push(name); });\n  }\n  function onCall(node) {\n    callHandlers.forEach(function (handler) { handler.push(node); });\n  }\n  function testForBreakOrReturnOrYieldOrThrow(fn) {\n    var before = {hasBreak: hasBreak, hasReturnOrYield: hasReturnOrYield, hasThrow: hasThrow, breakLabels: breakLabels};\n    hasBreak = false; hasReturnOrYield = false; hasThrow = false; breakLabels = [];\n    fn();\n    var result = hasBreak || hasReturnOrYield || hasThrow || breakLabels.length;\n    hasBreak = before.hasBreak;\n    hasReturnOrYield = hasReturnOrYield || before.hasReturnOrYield;\n    hasThrow = hasThrow || before.hasThrow;\n    breakLabels = before.breakLabels.concat(breakLabels);\n    return result;\n  }\n  function whileStatement(node, state, walk) {\n    var test, body;\n    var hasBreak = testForBreakOrReturnOrYieldOrThrow(function () {\n      test = watch(function () {\n        walk(node.test, state, "Expression");\n      });\n      body = watch(function () {\n        walk(node.body, state, "Statement");\n      });\n    });\n    var reads = test.reads;\n    var writes = test.writes.concat(body.writes);\n    var calls = test.calls.concat(body.calls);\n    if (hasBreak) {\n      return;\n    }\n    if (reads.length === 0) {\n      var err = new Error(\'while statement on line \' + node.test.loc.start.line +\n                          \' has a constant test.  Either it is always `false` \' +\n                          \'(making the statement redundant) or it is an infinite loop.\');\n      err.line = node.test.start.line;\n      err.node = node;\n      throw err;\n    }\n    if (calls.length || reads.some(function (name) { return writes.indexOf(name) !== -1; })) {\n      return;\n    }\n    var err = new Error(\'while statement on line \' + node.test.loc.start.line +\n                        \' has a test that contains no variables that get modified \' +\n                        \'in the loop. Either it is always `false` \' +\n                        \'(making the statement redundant) or it is an infinite loop.\');\n    err.line = node.test.loc.start.line;\n    err.node = node;\n    throw err;\n  }\n  function callExpression(node, st, c) {\n      onCall(node);\n      c(node.callee, st, "Expression");\n      if (node.arguments) {\n        for (var i = 0; i < node.arguments.length; ++i) {\n          c(node.arguments[i], st, "Expression");\n        }\n      }\n    }\n  walk.recursive(ast, {}, {\n    WhileStatement: whileStatement,\n    DoWhileStatement: whileStatement,\n    Identifier: function (node) { onRead(node.name); },\n    ThisExpression: function (node) { onRead(\'this\'); },\n    CallExpression: callExpression,\n    NewExpression: callExpression,\n    AssignmentExpression: function (node, st, c) {\n      watch(function () {\n        c(node.left, st, "Expression");\n      }).reads.forEach(onWrite);\n      c(node.right, st, "Expression");\n    },\n    UpdateExpression: function (node, st, c) {\n      watch(function () {\n        c(node.argument, st, "Expression");\n      }).reads.forEach(onWrite);\n    },\n\n    BreakStatement: function (node) {\n      if (node.label) {\n        breakLabels = breakLabels.concat([node.label.name]);\n      }\n      hasBreak = true;\n    },\n    LabeledStatement: function (node, st, c) {\n      var before = breakLabels;\n      c(node.body, st, "Statement");\n      breakLabels = breakLabels.filter(function (name) { return name !== node.label.name || before.indexOf(name) !== -1; });\n    },\n\n    ReturnStatement: function (node, st, c) {\n      if (node.argument) c(node.argument, st, "Expression");\n      hasReturnOrYield = true;\n    },\n    YieldExpression: function (node, st, c) {\n      if (node.argument) c(node.argument, st, "Expression");\n      hasReturnOrYield = true;\n    },\n    ThrowStatement: function (node, st, c) {\n      c(node.argument, st, "Expression");\n      hasThrow = true;\n    },\n    Function: function (node, st, c) {\n      var hasBreakBefore;\n      var breakLabelsBefore = breakLabels;\n      var hasThrowBefore = hasThrow;\n      var hasReturnOrYieldBefore = hasReturnOrYield;\n      c(node.body, st, "Statement");\n      hasBreak = hasBreakBefore;\n      breakLabels = breakLabelsBefore;\n      hasThrow = hasThrowBefore;\n      hasReturnOrYield = hasReturnOrYieldBefore;\n    },\n    TryStatement: function (node, st, c) {\n      var hasThrowBefore = hasThrow;\n      c(node.block, st, "Statement");\n      hasThrow = hasThrowBefore;\n      if (node.handler) c(node.handler.body, st, "Statement");\n      if (node.finalizer) c(node.finalizer, st, "Statement");\n    }\n  });\n}\n\n\n//# sourceURL=webpack:///./node_modules/halting-problem/lib/halting-problem.js?')},"./node_modules/halting-problem/lib/loop-protect.js":function(module,exports,__webpack_require__){"use strict";eval("\n\n// inspired by https://github.com/jsbin/loop-protect\n\nvar acorn = __webpack_require__(\"./node_modules/halting-problem/node_modules/acorn/dist/acorn.mjs\");\nvar walk = __webpack_require__(\"./node_modules/halting-problem/node_modules/acorn-walk/dist/walk.mjs\");\n\nmodule.exports = protect;\nfunction protect(src, protectFn) {\n  protectFn = protectFn || 'haltingProblem.protect';\n  var ast = acorn.parse(src, {\n    ecmaVersion: 2020,\n    allowReturnOutsideFunction: true,\n    allowImportExportEverywhere: true,\n    allowHashBang: true,\n    locations: true\n  });\n\n  src = src.split('');\n  function source(node) {\n    return src.slice(node.start, node.end).join('')\n  }\n  function replace(node, str) {\n    for (var i = node.start; i < node.end; i++) {\n      src[i] = ''\n    }\n    src[node.start] = str\n  }\n\n  function loopStatement(node) {\n    var line = (node.test || node.left).loc.start.line;\n    if (node.body.type === 'BlockStatement') {\n      var src = source(node.body).split('{');\n      src[1] = protectFn + '(' + line + ');' + src[1];\n      src = src.join('{');\n      replace(node.body, src);\n    } else {\n      replace(node.body, '{' + protectFn + '(' + line + ');' + source(node.body) + '}');\n    }\n  }\n  function functionExpression(node) {\n    if (node.body.type === 'BlockStatement') {\n      replace(node.body, '{' + protectFn + '(' + node.loc.start.line + ');' + source(node.body).split('{').slice(1).join('{'));\n    }\n  }\n\n  walk.simple(ast, {\n    WhileStatement: loopStatement,\n    DoWhileStatement: loopStatement,\n    ForStatement: loopStatement,\n    ForInStatement: loopStatement,\n    ForOfStatement: loopStatement,\n\n    FunctionExpression: functionExpression,\n    FunctionDeclaration: functionExpression,\n    ArrowFunctionExpression: functionExpression\n  });\n\n  return src.join('');\n}\n\n\n//# sourceURL=webpack:///./node_modules/halting-problem/lib/loop-protect.js?")},"./node_modules/halting-problem/lib/runtime.js":function(module,exports,__webpack_require__){"use strict";eval("\n\nvar start = Date.now();\n\nmodule.exports.reset = function (time) {\n  time = time || 1000;\n  start = Date.now() + time;\n};\nmodule.exports.protect = function (line) {\n  if (Date.now() > start) {\n    var err = new Error('Possible infinite loop detected on line ' + line);\n    throw err;\n  }\n};\n\n//# sourceURL=webpack:///./node_modules/halting-problem/lib/runtime.js?")},"./node_modules/halting-problem/node_modules/acorn-walk/dist/walk.mjs":function(__webpack_module__,__webpack_exports__,__webpack_require__){"use strict";eval('__webpack_require__.r(__webpack_exports__);\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ancestor", function() { return ancestor; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "base", function() { return base; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findNodeAfter", function() { return findNodeAfter; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findNodeAround", function() { return findNodeAround; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findNodeAt", function() { return findNodeAt; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "findNodeBefore", function() { return findNodeBefore; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "full", function() { return full; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fullAncestor", function() { return fullAncestor; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "make", function() { return make; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "recursive", function() { return recursive; });\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "simple", function() { return simple; });\n// AST walker module for Mozilla Parser API compatible trees\n\n// A simple walk is one where you simply specify callbacks to be\n// called on specific nodes. The last two arguments are optional. A\n// simple use would be\n//\n//     walk.simple(myTree, {\n//         Expression: function(node) { ... }\n//     });\n//\n// to do something with all expressions. All Parser API node types\n// can be used to identify node types, as well as Expression and\n// Statement, which denote categories of nodes.\n//\n// The base argument can be used to pass a custom (recursive)\n// walker, and state can be used to give this walked an initial\n// state.\n\nfunction simple(node, visitors, baseVisitor, state, override) {\n  if (!baseVisitor) { baseVisitor = base\n  ; }(function c(node, st, override) {\n    var type = override || node.type, found = visitors[type];\n    baseVisitor[type](node, st, c);\n    if (found) { found(node, st); }\n  })(node, state, override);\n}\n\n// An ancestor walk keeps an array of ancestor nodes (including the\n// current node) and passes them to the callback as third parameter\n// (and also as state parameter when no other state is present).\nfunction ancestor(node, visitors, baseVisitor, state) {\n  var ancestors = [];\n  if (!baseVisitor) { baseVisitor = base\n  ; }(function c(node, st, override) {\n    var type = override || node.type, found = visitors[type];\n    var isNew = node !== ancestors[ancestors.length - 1];\n    if (isNew) { ancestors.push(node); }\n    baseVisitor[type](node, st, c);\n    if (found) { found(node, st || ancestors, ancestors); }\n    if (isNew) { ancestors.pop(); }\n  })(node, state);\n}\n\n// A recursive walk is one where your functions override the default\n// walkers. They can modify and replace the state parameter that\'s\n// threaded through the walk, and can opt how and whether to walk\n// their child nodes (by calling their third argument on these\n// nodes).\nfunction recursive(node, state, funcs, baseVisitor, override) {\n  var visitor = funcs ? make(funcs, baseVisitor || undefined) : baseVisitor\n  ;(function c(node, st, override) {\n    visitor[override || node.type](node, st, c);\n  })(node, state, override);\n}\n\nfunction makeTest(test) {\n  if (typeof test === "string")\n    { return function (type) { return type === test; } }\n  else if (!test)\n    { return function () { return true; } }\n  else\n    { return test }\n}\n\nvar Found = function Found(node, state) { this.node = node; this.state = state; };\n\n// A full walk triggers the callback on each node\nfunction full(node, callback, baseVisitor, state, override) {\n  if (!baseVisitor) { baseVisitor = base\n  ; }(function c(node, st, override) {\n    var type = override || node.type;\n    baseVisitor[type](node, st, c);\n    if (!override) { callback(node, st, type); }\n  })(node, state, override);\n}\n\n// An fullAncestor walk is like an ancestor walk, but triggers\n// the callback on each node\nfunction fullAncestor(node, callback, baseVisitor, state) {\n  if (!baseVisitor) { baseVisitor = base; }\n  var ancestors = []\n  ;(function c(node, st, override) {\n    var type = override || node.type;\n    var isNew = node !== ancestors[ancestors.length - 1];\n    if (isNew) { ancestors.push(node); }\n    baseVisitor[type](node, st, c);\n    if (!override) { callback(node, st || ancestors, ancestors, type); }\n    if (isNew) { ancestors.pop(); }\n  })(node, state);\n}\n\n// Find a node with a given start, end, and type (all are optional,\n// null can be used as wildcard). Returns a {node, state} object, or\n// undefined when it doesn\'t find a matching node.\nfunction findNodeAt(node, start, end, test, baseVisitor, state) {\n  if (!baseVisitor) { baseVisitor = base; }\n  test = makeTest(test);\n  try {\n    (function c(node, st, override) {\n      var type = override || node.type;\n      if ((start == null || node.start <= start) &&\n          (end == null || node.end >= end))\n        { baseVisitor[type](node, st, c); }\n      if ((start == null || node.start === start) &&\n          (end == null || node.end === end) &&\n          test(type, node))\n        { throw new Found(node, st) }\n    })(node, state);\n  } catch (e) {\n    if (e instanceof Found) { return e }\n    throw e\n  }\n}\n\n// Find the innermost node of a given type that contains the given\n// position. Interface similar to findNodeAt.\nfunction findNodeAround(node, pos, test, baseVisitor, state) {\n  test = makeTest(test);\n  if (!baseVisitor) { baseVisitor = base; }\n  try {\n    (function c(node, st, override) {\n      var type = override || node.type;\n      if (node.start > pos || node.end < pos) { return }\n      baseVisitor[type](node, st, c);\n      if (test(type, node)) { throw new Found(node, st) }\n    })(node, state);\n  } catch (e) {\n    if (e instanceof Found) { return e }\n    throw e\n  }\n}\n\n// Find the outermost matching node after a given position.\nfunction findNodeAfter(node, pos, test, baseVisitor, state) {\n  test = makeTest(test);\n  if (!baseVisitor) { baseVisitor = base; }\n  try {\n    (function c(node, st, override) {\n      if (node.end < pos) { return }\n      var type = override || node.type;\n      if (node.start >= pos && test(type, node)) { throw new Found(node, st) }\n      baseVisitor[type](node, st, c);\n    })(node, state);\n  } catch (e) {\n    if (e instanceof Found) { return e }\n    throw e\n  }\n}\n\n// Find the outermost matching node before a given position.\nfunction findNodeBefore(node, pos, test, baseVisitor, state) {\n  test = makeTest(test);\n  if (!baseVisitor) { baseVisitor = base; }\n  var max\n  ;(function c(node, st, override) {\n    if (node.start > pos) { return }\n    var type = override || node.type;\n    if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))\n      { max = new Found(node, st); }\n    baseVisitor[type](node, st, c);\n  })(node, state);\n  return max\n}\n\n// Fallback to an Object.create polyfill for older environments.\nvar create = Object.create || function(proto) {\n  function Ctor() {}\n  Ctor.prototype = proto;\n  return new Ctor\n};\n\n// Used to create a custom walker. Will fill in all missing node\n// type properties with the defaults.\nfunction make(funcs, baseVisitor) {\n  var visitor = create(baseVisitor || base);\n  for (var type in funcs) { visitor[type] = funcs[type]; }\n  return visitor\n}\n\nfunction skipThrough(node, st, c) { c(node, st); }\nfunction ignore(_node, _st, _c) {}\n\n// Node walkers.\n\nvar base = {};\n\nbase.Program = base.BlockStatement = function (node, st, c) {\n  for (var i = 0, list = node.body; i < list.length; i += 1)\n    {\n    var stmt = list[i];\n\n    c(stmt, st, "Statement");\n  }\n};\nbase.Statement = skipThrough;\nbase.EmptyStatement = ignore;\nbase.ExpressionStatement = base.ParenthesizedExpression =\n  function (node, st, c) { return c(node.expression, st, "Expression"); };\nbase.IfStatement = function (node, st, c) {\n  c(node.test, st, "Expression");\n  c(node.consequent, st, "Statement");\n  if (node.alternate) { c(node.alternate, st, "Statement"); }\n};\nbase.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); };\nbase.BreakStatement = base.ContinueStatement = ignore;\nbase.WithStatement = function (node, st, c) {\n  c(node.object, st, "Expression");\n  c(node.body, st, "Statement");\n};\nbase.SwitchStatement = function (node, st, c) {\n  c(node.discriminant, st, "Expression");\n  for (var i$1 = 0, list$1 = node.cases; i$1 < list$1.length; i$1 += 1) {\n    var cs = list$1[i$1];\n\n    if (cs.test) { c(cs.test, st, "Expression"); }\n    for (var i = 0, list = cs.consequent; i < list.length; i += 1)\n      {\n      var cons = list[i];\n\n      c(cons, st, "Statement");\n    }\n  }\n};\nbase.SwitchCase = function (node, st, c) {\n  if (node.test) { c(node.test, st, "Expression"); }\n  for (var i = 0, list = node.consequent; i < list.length; i += 1)\n    {\n    var cons = list[i];\n\n    c(cons, st, "Statement");\n  }\n};\nbase.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {\n  if (node.argument) { c(node.argument, st, "Expression"); }\n};\nbase.ThrowStatement = base.SpreadElement =\n  function (node, st, c) { return c(node.argument, st, "Expression"); };\nbase.TryStatement = function (node, st, c) {\n  c(node.block, st, "Statement");\n  if (node.handler) { c(node.handler, st); }\n  if (node.finalizer) { c(node.finalizer, st, "Statement"); }\n};\nbase.CatchClause = function (node, st, c) {\n  if (node.param) { c(node.param, st, "Pattern"); }\n  c(node.body, st, "Statement");\n};\nbase.WhileStatement = base.DoWhileStatement = function (node, st, c) {\n  c(node.test, st, "Expression");\n  c(node.body, st, "Statement");\n};\nbase.ForStatement = function (node, st, c) {\n  if (node.init) { c(node.init, st, "ForInit"); }\n  if (node.test) { c(node.test, st, "Expression"); }\n  if (node.update) { c(node.update, st, "Expression"); }\n  c(node.body, st, "Statement");\n};\nbase.ForInStatement = base.ForOfStatement = function (node, st, c) {\n  c(node.left, st, "ForInit");\n  c(node.right, st, "Expression");\n  c(node.body, st, "Statement");\n};\nbase.ForInit = function (node, st, c) {\n  if (node.type === "VariableDeclaration") { c(node, st); }\n  else { c(node, st, "Expression"); }\n};\nbase.DebuggerStatement = ignore;\n\nbase.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); };\nbase.VariableDeclaration = function (node, st, c) {\n  for (var i = 0, list = node.declarations; i < list.length; i += 1)\n    {\n    var decl = list[i];\n\n    c(decl, st);\n  }\n};\nbase.VariableDeclarator = function (node, st, c) {\n  c(node.id, st, "Pattern");\n  if (node.init) { c(node.init, st, "Expression"); }\n};\n\nbase.Function = function (node, st, c) {\n  if (node.id) { c(node.id, st, "Pattern"); }\n  for (var i = 0, list = node.params; i < list.length; i += 1)\n    {\n    var param = list[i];\n\n    c(param, st, "Pattern");\n  }\n  c(node.body, st, node.expression ? "Expression" : "Statement");\n};\n\nbase.Pattern = function (node, st, c) {\n  if (node.type === "Identifier")\n    { c(node, st, "VariablePattern"); }\n  else if (node.type === "MemberExpression")\n    { c(node, st, "MemberPattern"); }\n  else\n    { c(node, st); }\n};\nbase.VariablePattern = ignore;\nbase.MemberPattern = skipThrough;\nbase.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); };\nbase.ArrayPattern = function (node, st, c) {\n  for (var i = 0, list = node.elements; i < list.length; i += 1) {\n    var elt = list[i];\n\n    if (elt) { c(elt, st, "Pattern"); }\n  }\n};\nbase.ObjectPattern = function (node, st, c) {\n  for (var i = 0, list = node.properties; i < list.length; i += 1) {\n    var prop = list[i];\n\n    if (prop.type === "Property") {\n      if (prop.computed) { c(prop.key, st, "Expression"); }\n      c(prop.value, st, "Pattern");\n    } else if (prop.type === "RestElement") {\n      c(prop.argument, st, "Pattern");\n    }\n  }\n};\n\nbase.Expression = skipThrough;\nbase.ThisExpression = base.Super = base.MetaProperty = ignore;\nbase.ArrayExpression = function (node, st, c) {\n  for (var i = 0, list = node.elements; i < list.length; i += 1) {\n    var elt = list[i];\n\n    if (elt) { c(elt, st, "Expression"); }\n  }\n};\nbase.ObjectExpression = function (node, st, c) {\n  for (var i = 0, list = node.properties; i < list.length; i += 1)\n    {\n    var prop = list[i];\n\n    c(prop, st);\n  }\n};\nbase.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;\nbase.SequenceExpression = function (node, st, c) {\n  for (var i = 0, list = node.expressions; i < list.length; i += 1)\n    {\n    var expr = list[i];\n\n    c(expr, st, "Expression");\n  }\n};\nbase.TemplateLiteral = function (node, st, c) {\n  for (var i = 0, list = node.quasis; i < list.length; i += 1)\n    {\n    var quasi = list[i];\n\n    c(quasi, st);\n  }\n\n  for (var i$1 = 0, list$1 = node.expressions; i$1 < list$1.length; i$1 += 1)\n    {\n    var expr = list$1[i$1];\n\n    c(expr, st, "Expression");\n  }\n};\nbase.TemplateElement = ignore;\nbase.UnaryExpression = base.UpdateExpression = function (node, st, c) {\n  c(node.argument, st, "Expression");\n};\nbase.BinaryExpression = base.LogicalExpression = function (node, st, c) {\n  c(node.left, st, "Expression");\n  c(node.right, st, "Expression");\n};\nbase.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {\n  c(node.left, st, "Pattern");\n  c(node.right, st, "Expression");\n};\nbase.ConditionalExpression = function (node, st, c) {\n  c(node.test, st, "Expression");\n  c(node.consequent, st, "Expression");\n  c(node.alternate, st, "Expression");\n};\nbase.NewExpression = base.CallExpression = function (node, st, c) {\n  c(node.callee, st, "Expression");\n  if (node.arguments)\n    { for (var i = 0, list = node.arguments; i < list.length; i += 1)\n      {\n        var arg = list[i];\n\n        c(arg, st, "Expression");\n      } }\n};\nbase.MemberExpression = function (node, st, c) {\n  c(node.object, st, "Expression");\n  if (node.computed) { c(node.property, st, "Expression"); }\n};\nbase.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {\n  if (node.declaration)\n    { c(node.declaration, st, node.type === "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); }\n  if (node.source) { c(node.source, st, "Expression"); }\n};\nbase.ExportAllDeclaration = function (node, st, c) {\n  c(node.source, st, "Expression");\n};\nbase.ImportDeclaration = function (node, st, c) {\n  for (var i = 0, list = node.specifiers; i < list.length; i += 1)\n    {\n    var spec = list[i];\n\n    c(spec, st);\n  }\n  c(node.source, st, "Expression");\n};\nbase.ImportExpression = function (node, st, c) {\n  c(node.source, st, "Expression");\n};\nbase.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore;\n\nbase.TaggedTemplateExpression = function (node, st, c) {\n  c(node.tag, st, "Expression");\n  c(node.quasi, st, "Expression");\n};\nbase.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); };\nbase.Class = function (node, st, c) {\n  if (node.id) { c(node.id, st, "Pattern"); }\n  if (node.superClass) { c(node.superClass, st, "Expression"); }\n  c(node.body, st);\n};\nbase.ClassBody = function (node, st, c) {\n  for (var i = 0, list = node.body; i < list.length; i += 1)\n    {\n    var elt = list[i];\n\n    c(elt, st);\n  }\n};\nbase.MethodDefinition = base.Property = function (node, st, c) {\n  if (node.computed) { c(node.key, st, "Expression"); }\n  c(node.value, st, "Expression");\n};\n\n\n\n\n//# sourceURL=webpack:///./node_modules/halting-problem/node_modules/acorn-walk/dist/walk.mjs?')},"./node_modules/halting-problem/node_modules/acorn/dist/acorn.mjs":function(module,exports,__webpack_require__){"use strict";eval('\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\nexports.defaultOptions = exports.TokenType = exports.Token = exports.TokContext = exports.SourceLocation = exports.Position = exports.Parser = exports.Node = void 0;\nexports.getLineInfo = getLineInfo;\nexports.isIdentifierChar = isIdentifierChar;\nexports.isIdentifierStart = isIdentifierStart;\nexports.isNewLine = isNewLine;\nexports.nonASCIIwhitespace = exports.lineBreakG = exports.lineBreak = exports.keywordTypes = void 0;\nexports.parse = parse;\nexports.parseExpressionAt = parseExpressionAt;\nexports.tokTypes = exports.tokContexts = void 0;\nexports.tokenizer = tokenizer;\nexports.version = void 0;\n// Reserved word lists for various dialects of the language\nvar reservedWords = {\n  3: "abstract boolean byte char class double enum export extends final float goto implements import int interface long native package private protected public short static super synchronized throws transient volatile",\n  5: "class enum extends super const export import",\n  6: "enum",\n  strict: "implements interface let package private protected public static yield",\n  strictBind: "eval arguments"\n}; // And the keywords\n\nvar ecma5AndLessKeywords = "break case catch continue debugger default do else finally for function if return switch throw try var while with null true false instanceof typeof void delete new in this";\nvar keywords = {\n  5: ecma5AndLessKeywords,\n  "5module": ecma5AndLessKeywords + " export import",\n  6: ecma5AndLessKeywords + " const class extends export import super"\n};\nvar keywordRelationalOperator = /^in(stanceof)?$/; // ## Character categories\n// Big ugly regular expressions that match characters in the\n// whitespace, identifier, and identifier-start categories. These\n// are only applied when a character is found to actually have a\n// code point above 128.\n// Generated by `bin/generate-identifier-regex.js`.\n\nvar nonASCIIidentifierStartChars = "\\xAA\\xB5\\xBA\\xC0-\\xD6\\xD8-\\xF6\\xF8-\\u02C1\\u02C6-\\u02D1\\u02E0-\\u02E4\\u02EC\\u02EE\\u0370-\\u0374\\u0376\\u0377\\u037A-\\u037D\\u037F\\u0386\\u0388-\\u038A\\u038C\\u038E-\\u03A1\\u03A3-\\u03F5\\u03F7-\\u0481\\u048A-\\u052F\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05D0-\\u05EA\\u05EF-\\u05F2\\u0620-\\u064A\\u066E\\u066F\\u0671-\\u06D3\\u06D5\\u06E5\\u06E6\\u06EE\\u06EF\\u06FA-\\u06FC\\u06FF\\u0710\\u0712-\\u072F\\u074D-\\u07A5\\u07B1\\u07CA-\\u07EA\\u07F4\\u07F5\\u07FA\\u0800-\\u0815\\u081A\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086A\\u08A0-\\u08B4\\u08B6-\\u08BD\\u0904-\\u0939\\u093D\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098C\\u098F\\u0990\\u0993-\\u09A8\\u09AA-\\u09B0\\u09B2\\u09B6-\\u09B9\\u09BD\\u09CE\\u09DC\\u09DD\\u09DF-\\u09E1\\u09F0\\u09F1\\u09FC\\u0A05-\\u0A0A\\u0A0F\\u0A10\\u0A13-\\u0A28\\u0A2A-\\u0A30\\u0A32\\u0A33\\u0A35\\u0A36\\u0A38\\u0A39\\u0A59-\\u0A5C\\u0A5E\\u0A72-\\u0A74\\u0A85-\\u0A8D\\u0A8F-\\u0A91\\u0A93-\\u0AA8\\u0AAA-\\u0AB0\\u0AB2\\u0AB3\\u0AB5-\\u0AB9\\u0ABD\\u0AD0\\u0AE0\\u0AE1\\u0AF9\\u0B05-\\u0B0C\\u0B0F\\u0B10\\u0B13-\\u0B28\\u0B2A-\\u0B30\\u0B32\\u0B33\\u0B35-\\u0B39\\u0B3D\\u0B5C\\u0B5D\\u0B5F-\\u0B61\\u0B71\\u0B83\\u0B85-\\u0B8A\\u0B8E-\\u0B90\\u0B92-\\u0B95\\u0B99\\u0B9A\\u0B9C\\u0B9E\\u0B9F\\u0BA3\\u0BA4\\u0BA8-\\u0BAA\\u0BAE-\\u0BB9\\u0BD0\\u0C05-\\u0C0C\\u0C0E-\\u0C10\\u0C12-\\u0C28\\u0C2A-\\u0C39\\u0C3D\\u0C58-\\u0C5A\\u0C60\\u0C61\\u0C80\\u0C85-\\u0C8C\\u0C8E-\\u0C90\\u0C92-\\u0CA8\\u0CAA-\\u0CB3\\u0CB5-\\u0CB9\\u0CBD\\u0CDE\\u0CE0\\u0CE1\\u0CF1\\u0CF2\\u0D05-\\u0D0C\\u0D0E-\\u0D10\\u0D12-\\u0D3A\\u0D3D\\u0D4E\\u0D54-\\u0D56\\u0D5F-\\u0D61\\u0D7A-\\u0D7F\\u0D85-\\u0D96\\u0D9A-\\u0DB1\\u0DB3-\\u0DBB\\u0DBD\\u0DC0-\\u0DC6\\u0E01-\\u0E30\\u0E32\\u0E33\\u0E40-\\u0E46\\u0E81\\u0E82\\u0E84\\u0E86-\\u0E8A\\u0E8C-\\u0EA3\\u0EA5\\u0EA7-\\u0EB0\\u0EB2\\u0EB3\\u0EBD\\u0EC0-\\u0EC4\\u0EC6\\u0EDC-\\u0EDF\\u0F00\\u0F40-\\u0F47\\u0F49-\\u0F6C\\u0F88-\\u0F8C\\u1000-\\u102A\\u103F\\u1050-\\u1055\\u105A-\\u105D\\u1061\\u1065\\u1066\\u106E-\\u1070\\u1075-\\u1081\\u108E\\u10A0-\\u10C5\\u10C7\\u10CD\\u10D0-\\u10FA\\u10FC-\\u1248\\u124A-\\u124D\\u1250-\\u1256\\u1258\\u125A-\\u125D\\u1260-\\u1288\\u128A-\\u128D\\u1290-\\u12B0\\u12B2-\\u12B5\\u12B8-\\u12BE\\u12C0\\u12C2-\\u12C5\\u12C8-\\u12D6\\u12D8-\\u1310\\u1312-\\u1315\\u1318-\\u135A\\u1380-\\u138F\\u13A0-\\u13F5\\u13F8-\\u13FD\\u1401-\\u166C\\u166F-\\u167F\\u1681-\\u169A\\u16A0-\\u16EA\\u16EE-\\u16F8\\u1700-\\u170C\\u170E-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176C\\u176E-\\u1770\\u1780-\\u17B3\\u17D7\\u17DC\\u1820-\\u1878\\u1880-\\u18A8\\u18AA\\u18B0-\\u18F5\\u1900-\\u191E\\u1950-\\u196D\\u1970-\\u1974\\u1980-\\u19AB\\u19B0-\\u19C9\\u1A00-\\u1A16\\u1A20-\\u1A54\\u1AA7\\u1B05-\\u1B33\\u1B45-\\u1B4B\\u1B83-\\u1BA0\\u1BAE\\u1BAF\\u1BBA-\\u1BE5\\u1C00-\\u1C23\\u1C4D-\\u1C4F\\u1C5A-\\u1C7D\\u1C80-\\u1C88\\u1C90-\\u1CBA\\u1CBD-\\u1CBF\\u1CE9-\\u1CEC\\u1CEE-\\u1CF3\\u1CF5\\u1CF6\\u1CFA\\u1D00-\\u1DBF\\u1E00-\\u1F15\\u1F18-\\u1F1D\\u1F20-\\u1F45\\u1F48-\\u1F4D\\u1F50-\\u1F57\\u1F59\\u1F5B\\u1F5D\\u1F5F-\\u1F7D\\u1F80-\\u1FB4\\u1FB6-\\u1FBC\\u1FBE\\u1FC2-\\u1FC4\\u1FC6-\\u1FCC\\u1FD0-\\u1FD3\\u1FD6-\\u1FDB\\u1FE0-\\u1FEC\\u1FF2-\\u1FF4\\u1FF6-\\u1FFC\\u2071\\u207F\\u2090-\\u209C\\u2102\\u2107\\u210A-\\u2113\\u2115\\u2118-\\u211D\\u2124\\u2126\\u2128\\u212A-\\u2139\\u213C-\\u213F\\u2145-\\u2149\\u214E\\u2160-\\u2188\\u2C00-\\u2C2E\\u2C30-\\u2C5E\\u2C60-\\u2CE4\\u2CEB-\\u2CEE\\u2CF2\\u2CF3\\u2D00-\\u2D25\\u2D27\\u2D2D\\u2D30-\\u2D67\\u2D6F\\u2D80-\\u2D96\\u2DA0-\\u2DA6\\u2DA8-\\u2DAE\\u2DB0-\\u2DB6\\u2DB8-\\u2DBE\\u2DC0-\\u2DC6\\u2DC8-\\u2DCE\\u2DD0-\\u2DD6\\u2DD8-\\u2DDE\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303C\\u3041-\\u3096\\u309B-\\u309F\\u30A1-\\u30FA\\u30FC-\\u30FF\\u3105-\\u312F\\u3131-\\u318E\\u31A0-\\u31BA\\u31F0-\\u31FF\\u3400-\\u4DB5\\u4E00-\\u9FEF\\uA000-\\uA48C\\uA4D0-\\uA4FD\\uA500-\\uA60C\\uA610-\\uA61F\\uA62A\\uA62B\\uA640-\\uA66E\\uA67F-\\uA69D\\uA6A0-\\uA6EF\\uA717-\\uA71F\\uA722-\\uA788\\uA78B-\\uA7BF\\uA7C2-\\uA7C6\\uA7F7-\\uA801\\uA803-\\uA805\\uA807-\\uA80A\\uA80C-\\uA822\\uA840-\\uA873\\uA882-\\uA8B3\\uA8F2-\\uA8F7\\uA8FB\\uA8FD\\uA8FE\\uA90A-\\uA925\\uA930-\\uA946\\uA960-\\uA97C\\uA984-\\uA9B2\\uA9CF\\uA9E0-\\uA9E4\\uA9E6-\\uA9EF\\uA9FA-\\uA9FE\\uAA00-\\uAA28\\uAA40-\\uAA42\\uAA44-\\uAA4B\\uAA60-\\uAA76\\uAA7A\\uAA7E-\\uAAAF\\uAAB1\\uAAB5\\uAAB6\\uAAB9-\\uAABD\\uAAC0\\uAAC2\\uAADB-\\uAADD\\uAAE0-\\uAAEA\\uAAF2-\\uAAF4\\uAB01-\\uAB06\\uAB09-\\uAB0E\\uAB11-\\uAB16\\uAB20-\\uAB26\\uAB28-\\uAB2E\\uAB30-\\uAB5A\\uAB5C-\\uAB67\\uAB70-\\uABE2\\uAC00-\\uD7A3\\uD7B0-\\uD7C6\\uD7CB-\\uD7FB\\uF900-\\uFA6D\\uFA70-\\uFAD9\\uFB00-\\uFB06\\uFB13-\\uFB17\\uFB1D\\uFB1F-\\uFB28\\uFB2A-\\uFB36\\uFB38-\\uFB3C\\uFB3E\\uFB40\\uFB41\\uFB43\\uFB44\\uFB46-\\uFBB1\\uFBD3-\\uFD3D\\uFD50-\\uFD8F\\uFD92-\\uFDC7\\uFDF0-\\uFDFB\\uFE70-\\uFE74\\uFE76-\\uFEFC\\uFF21-\\uFF3A\\uFF41-\\uFF5A\\uFF66-\\uFFBE\\uFFC2-\\uFFC7\\uFFCA-\\uFFCF\\uFFD2-\\uFFD7\\uFFDA-\\uFFDC";\nvar nonASCIIidentifierChars = "\\u200C\\u200D\\xB7\\u0300-\\u036F\\u0387\\u0483-\\u0487\\u0591-\\u05BD\\u05BF\\u05C1\\u05C2\\u05C4\\u05C5\\u05C7\\u0610-\\u061A\\u064B-\\u0669\\u0670\\u06D6-\\u06DC\\u06DF-\\u06E4\\u06E7\\u06E8\\u06EA-\\u06ED\\u06F0-\\u06F9\\u0711\\u0730-\\u074A\\u07A6-\\u07B0\\u07C0-\\u07C9\\u07EB-\\u07F3\\u07FD\\u0816-\\u0819\\u081B-\\u0823\\u0825-\\u0827\\u0829-\\u082D\\u0859-\\u085B\\u08D3-\\u08E1\\u08E3-\\u0903\\u093A-\\u093C\\u093E-\\u094F\\u0951-\\u0957\\u0962\\u0963\\u0966-\\u096F\\u0981-\\u0983\\u09BC\\u09BE-\\u09C4\\u09C7\\u09C8\\u09CB-\\u09CD\\u09D7\\u09E2\\u09E3\\u09E6-\\u09EF\\u09FE\\u0A01-\\u0A03\\u0A3C\\u0A3E-\\u0A42\\u0A47\\u0A48\\u0A4B-\\u0A4D\\u0A51\\u0A66-\\u0A71\\u0A75\\u0A81-\\u0A83\\u0ABC\\u0ABE-\\u0AC5\\u0AC7-\\u0AC9\\u0ACB-\\u0ACD\\u0AE2\\u0AE3\\u0AE6-\\u0AEF\\u0AFA-\\u0AFF\\u0B01-\\u0B03\\u0B3C\\u0B3E-\\u0B44\\u0B47\\u0B48\\u0B4B-\\u0B4D\\u0B56\\u0B57\\u0B62\\u0B63\\u0B66-\\u0B6F\\u0B82\\u0BBE-\\u0BC2\\u0BC6-\\u0BC8\\u0BCA-\\u0BCD\\u0BD7\\u0BE6-\\u0BEF\\u0C00-\\u0C04\\u0C3E-\\u0C44\\u0C46-\\u0C48\\u0C4A-\\u0C4D\\u0C55\\u0C56\\u0C62\\u0C63\\u0C66-\\u0C6F\\u0C81-\\u0C83\\u0CBC\\u0CBE-\\u0CC4\\u0CC6-\\u0CC8\\u0CCA-\\u0CCD\\u0CD5\\u0CD6\\u0CE2\\u0CE3\\u0CE6-\\u0CEF\\u0D00-\\u0D03\\u0D3B\\u0D3C\\u0D3E-\\u0D44\\u0D46-\\u0D48\\u0D4A-\\u0D4D\\u0D57\\u0D62\\u0D63\\u0D66-\\u0D6F\\u0D82\\u0D83\\u0DCA\\u0DCF-\\u0DD4\\u0DD6\\u0DD8-\\u0DDF\\u0DE6-\\u0DEF\\u0DF2\\u0DF3\\u0E31\\u0E34-\\u0E3A\\u0E47-\\u0E4E\\u0E50-\\u0E59\\u0EB1\\u0EB4-\\u0EBC\\u0EC8-\\u0ECD\\u0ED0-\\u0ED9\\u0F18\\u0F19\\u0F20-\\u0F29\\u0F35\\u0F37\\u0F39\\u0F3E\\u0F3F\\u0F71-\\u0F84\\u0F86\\u0F87\\u0F8D-\\u0F97\\u0F99-\\u0FBC\\u0FC6\\u102B-\\u103E\\u1040-\\u1049\\u1056-\\u1059\\u105E-\\u1060\\u1062-\\u1064\\u1067-\\u106D\\u1071-\\u1074\\u1082-\\u108D\\u108F-\\u109D\\u135D-\\u135F\\u1369-\\u1371\\u1712-\\u1714\\u1732-\\u1734\\u1752\\u1753\\u1772\\u1773\\u17B4-\\u17D3\\u17DD\\u17E0-\\u17E9\\u180B-\\u180D\\u1810-\\u1819\\u18A9\\u1920-\\u192B\\u1930-\\u193B\\u1946-\\u194F\\u19D0-\\u19DA\\u1A17-\\u1A1B\\u1A55-\\u1A5E\\u1A60-\\u1A7C\\u1A7F-\\u1A89\\u1A90-\\u1A99\\u1AB0-\\u1ABD\\u1B00-\\u1B04\\u1B34-\\u1B44\\u1B50-\\u1B59\\u1B6B-\\u1B73\\u1B80-\\u1B82\\u1BA1-\\u1BAD\\u1BB0-\\u1BB9\\u1BE6-\\u1BF3\\u1C24-\\u1C37\\u1C40-\\u1C49\\u1C50-\\u1C59\\u1CD0-\\u1CD2\\u1CD4-\\u1CE8\\u1CED\\u1CF4\\u1CF7-\\u1CF9\\u1DC0-\\u1DF9\\u1DFB-\\u1DFF\\u203F\\u2040\\u2054\\u20D0-\\u20DC\\u20E1\\u20E5-\\u20F0\\u2CEF-\\u2CF1\\u2D7F\\u2DE0-\\u2DFF\\u302A-\\u302F\\u3099\\u309A\\uA620-\\uA629\\uA66F\\uA674-\\uA67D\\uA69E\\uA69F\\uA6F0\\uA6F1\\uA802\\uA806\\uA80B\\uA823-\\uA827\\uA880\\uA881\\uA8B4-\\uA8C5\\uA8D0-\\uA8D9\\uA8E0-\\uA8F1\\uA8FF-\\uA909\\uA926-\\uA92D\\uA947-\\uA953\\uA980-\\uA983\\uA9B3-\\uA9C0\\uA9D0-\\uA9D9\\uA9E5\\uA9F0-\\uA9F9\\uAA29-\\uAA36\\uAA43\\uAA4C\\uAA4D\\uAA50-\\uAA59\\uAA7B-\\uAA7D\\uAAB0\\uAAB2-\\uAAB4\\uAAB7\\uAAB8\\uAABE\\uAABF\\uAAC1\\uAAEB-\\uAAEF\\uAAF5\\uAAF6\\uABE3-\\uABEA\\uABEC\\uABED\\uABF0-\\uABF9\\uFB1E\\uFE00-\\uFE0F\\uFE20-\\uFE2F\\uFE33\\uFE34\\uFE4D-\\uFE4F\\uFF10-\\uFF19\\uFF3F";\nvar nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");\nvar nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");\nnonASCIIidentifierStartChars = nonASCIIidentifierChars = null; // These are a run-length and offset encoded representation of the\n// >0xffff code points that are a valid part of identifiers. The\n// offset starts at 0x10000, and each pair of numbers represents an\n// offset to the next range, and then a size of the range. They were\n// generated by bin/generate-identifier-regex.js\n// eslint-disable-next-line comma-spacing\n\nvar astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 157, 310, 10, 21, 11, 7, 153, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 477, 28, 11, 0, 9, 21, 155, 22, 13, 52, 76, 44, 33, 24, 27, 35, 30, 0, 12, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 0, 33, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 230, 43, 117, 63, 32, 0, 161, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 35, 56, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 270, 921, 103, 110, 18, 195, 2749, 1070, 4050, 582, 8634, 568, 8, 30, 114, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 754, 9486, 286, 50, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 2357, 44, 11, 6, 17, 0, 370, 43, 1301, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42710, 42, 4148, 12, 221, 3, 5761, 15, 7472, 3104, 541]; // eslint-disable-next-line comma-spacing\n\nvar astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 525, 10, 176, 2, 54, 14, 32, 9, 16, 3, 46, 10, 54, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 4, 9, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 232, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 135, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 19723, 1, 5319, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 419, 13, 1495, 6, 110, 6, 6, 9, 792487, 239]; // This has a complexity linear to the value of the code. The\n// assumption is that looking up astral identifier characters is\n// rare.\n\nfunction isInAstralSet(code, set) {\n  var pos = 0x10000;\n\n  for (var i = 0; i < set.length; i += 2) {\n    pos += set[i];\n\n    if (pos > code) {\n      return false;\n    }\n\n    pos += set[i + 1];\n\n    if (pos >= code) {\n      return true;\n    }\n  }\n} // Test whether a given character code starts an identifier.\n\n\nfunction isIdentifierStart(code, astral) {\n  if (code < 65) {\n    return code === 36;\n  }\n\n  if (code < 91) {\n    return true;\n  }\n\n  if (code < 97) {\n    return code === 95;\n  }\n\n  if (code < 123) {\n    return true;\n  }\n\n  if (code <= 0xffff) {\n    return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));\n  }\n\n  if (astral === false) {\n    return false;\n  }\n\n  return isInAstralSet(code, astralIdentifierStartCodes);\n} // Test whether a given character is part of an identifier.\n\n\nfunction isIdentifierChar(code, astral) {\n  if (code < 48) {\n    return code === 36;\n  }\n\n  if (code < 58) {\n    return true;\n  }\n\n  if (code < 65) {\n    return false;\n  }\n\n  if (code < 91) {\n    return true;\n  }\n\n  if (code < 97) {\n    return code === 95;\n  }\n\n  if (code < 123) {\n    return true;\n  }\n\n  if (code <= 0xffff) {\n    return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));\n  }\n\n  if (astral === false) {\n    return false;\n  }\n\n  return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);\n} // ## Token types\n// The assignment of fine-grained, information-carrying type objects\n// allows the tokenizer to store the information it has about a\n// token in a way that is very cheap for the parser to look up.\n// All token type variables start with an underscore, to make them\n// easy to recognize.\n// The `beforeExpr` property is used to disambiguate between regular\n// expressions and divisions. It is set on all token types that can\n// be followed by an expression (thus, a slash after them would be a\n// regular expression).\n//\n// The `startsExpr` property is used to check if the token ends a\n// `yield` expression. It is set on all token types that either can\n// directly start an expression (like a quotation mark) or can\n// continue an expression (like the body of a string).\n//\n// `isLoop` marks a keyword as starting a loop, which is important\n// to know when parsing a label, in order to allow or disallow\n// continue jumps to that label.\n\n\nvar TokenType = function TokenType(label, conf) {\n  if (conf === void 0) conf = {};\n  this.label = label;\n  this.keyword = conf.keyword;\n  this.beforeExpr = !!conf.beforeExpr;\n  this.startsExpr = !!conf.startsExpr;\n  this.isLoop = !!conf.isLoop;\n  this.isAssign = !!conf.isAssign;\n  this.prefix = !!conf.prefix;\n  this.postfix = !!conf.postfix;\n  this.binop = conf.binop || null;\n  this.updateContext = null;\n};\n\nexports.TokenType = TokenType;\n\nfunction binop(name, prec) {\n  return new TokenType(name, {\n    beforeExpr: true,\n    binop: prec\n  });\n}\n\nvar beforeExpr = {\n  beforeExpr: true\n},\n    startsExpr = {\n  startsExpr: true\n}; // Map keyword names to token types.\n\nvar keywords$1 = {}; // Succinct definitions of keyword token types\n\nexports.keywordTypes = keywords$1;\n\nfunction kw(name, options) {\n  if (options === void 0) options = {};\n  options.keyword = name;\n  return keywords$1[name] = new TokenType(name, options);\n}\n\nvar types = {\n  num: new TokenType("num", startsExpr),\n  regexp: new TokenType("regexp", startsExpr),\n  string: new TokenType("string", startsExpr),\n  name: new TokenType("name", startsExpr),\n  eof: new TokenType("eof"),\n  // Punctuation token types.\n  bracketL: new TokenType("[", {\n    beforeExpr: true,\n    startsExpr: true\n  }),\n  bracketR: new TokenType("]"),\n  braceL: new TokenType("{", {\n    beforeExpr: true,\n    startsExpr: true\n  }),\n  braceR: new TokenType("}"),\n  parenL: new TokenType("(", {\n    beforeExpr: true,\n    startsExpr: true\n  }),\n  parenR: new TokenType(")"),\n  comma: new TokenType(",", beforeExpr),\n  semi: new TokenType(";", beforeExpr),\n  colon: new TokenType(":", beforeExpr),\n  dot: new TokenType("."),\n  question: new TokenType("?", beforeExpr),\n  arrow: new TokenType("=>", beforeExpr),\n  template: new TokenType("template"),\n  invalidTemplate: new TokenType("invalidTemplate"),\n  ellipsis: new TokenType("...", beforeExpr),\n  backQuote: new TokenType("`", startsExpr),\n  dollarBraceL: new TokenType("${", {\n    beforeExpr: true,\n    startsExpr: true\n  }),\n  // Operators. These carry several kinds of properties to help the\n  // parser use them properly (the presence of these properties is\n  // what categorizes them as operators).\n  //\n  // `binop`, when present, specifies that this operator is a binary\n  // operator, and will refer to its precedence.\n  //\n  // `prefix` and `postfix` mark the operator as a prefix or postfix\n  // unary operator.\n  //\n  // `isAssign` marks all of `=`, `+=`, `-=` etcetera, which act as\n  // binary operators with a very low precedence, that should result\n  // in AssignmentExpression nodes.\n  eq: new TokenType("=", {\n    beforeExpr: true,\n    isAssign: true\n  }),\n  assign: new TokenType("_=", {\n    beforeExpr: true,\n    isAssign: true\n  }),\n  incDec: new TokenType("++/--", {\n    prefix: true,\n    postfix: true,\n    startsExpr: true\n  }),\n  prefix: new TokenType("!/~", {\n    beforeExpr: true,\n    prefix: true,\n    startsExpr: true\n  }),\n  logicalOR: binop("||", 1),\n  logicalAND: binop("&&", 2),\n  bitwiseOR: binop("|", 3),\n  bitwiseXOR: binop("^", 4),\n  bitwiseAND: binop("&", 5),\n  equality: binop("==/!=/===/!==", 6),\n  relational: binop("</>/<=/>=", 7),\n  bitShift: binop("<</>>/>>>", 8),\n  plusMin: new TokenType("+/-", {\n    beforeExpr: true,\n    binop: 9,\n    prefix: true,\n    startsExpr: true\n  }),\n  modulo: binop("%", 10),\n  star: binop("*", 10),\n  slash: binop("/", 10),\n  starstar: new TokenType("**", {\n    beforeExpr: true\n  }),\n  // Keyword token types.\n  _break: kw("break"),\n  _case: kw("case", beforeExpr),\n  _catch: kw("catch"),\n  _continue: kw("continue"),\n  _debugger: kw("debugger"),\n  _default: kw("default", beforeExpr),\n  _do: kw("do", {\n    isLoop: true,\n    beforeExpr: true\n  }),\n  _else: kw("else", beforeExpr),\n  _finally: kw("finally"),\n  _for: kw("for", {\n    isLoop: true\n  }),\n  _function: kw("function", startsExpr),\n  _if: kw("if"),\n  _return: kw("return", beforeExpr),\n  _switch: kw("switch"),\n  _throw: kw("throw", beforeExpr),\n  _try: kw("try"),\n  _var: kw("var"),\n  _const: kw("const"),\n  _while: kw("while", {\n    isLoop: true\n  }),\n  _with: kw("with"),\n  _new: kw("new", {\n    beforeExpr: true,\n    startsExpr: true\n  }),\n  _this: kw("this", startsExpr),\n  _super: kw("super", startsExpr),\n  _class: kw("class", startsExpr),\n  _extends: kw("extends", beforeExpr),\n  _export: kw("export"),\n  _import: kw("import", startsExpr),\n  _null: kw("null", startsExpr),\n  _true: kw("true", startsExpr),\n  _false: kw("false", startsExpr),\n  _in: kw("in", {\n    beforeExpr: true,\n    binop: 7\n  }),\n  _instanceof: kw("instanceof", {\n    beforeExpr: true,\n    binop: 7\n  }),\n  _typeof: kw("typeof", {\n    beforeExpr: true,\n    prefix: true,\n    startsExpr: true\n  }),\n  _void: kw("void", {\n    beforeExpr: true,\n    prefix: true,\n    startsExpr: true\n  }),\n  _delete: kw("delete", {\n    beforeExpr: true,\n    prefix: true,\n    startsExpr: true\n  })\n}; // Matches a whole line break (where CRLF is considered a single\n// line break). Used to count lines.\n\nexports.tokTypes = types;\nvar lineBreak = /\\r\\n?|\\n|\\u2028|\\u2029/;\nexports.lineBreak = lineBreak;\nvar lineBreakG = new RegExp(lineBreak.source, "g");\nexports.lineBreakG = lineBreakG;\n\nfunction isNewLine(code, ecma2019String) {\n  return code === 10 || code === 13 || !ecma2019String && (code === 0x2028 || code === 0x2029);\n}\n\nvar nonASCIIwhitespace = /[\\u1680\\u2000-\\u200a\\u202f\\u205f\\u3000\\ufeff]/;\nexports.nonASCIIwhitespace = nonASCIIwhitespace;\nvar skipWhiteSpace = /(?:\\s|\\/\\/.*|\\/\\*[^]*?\\*\\/)*/g;\nvar ref = Object.prototype;\nvar hasOwnProperty = ref.hasOwnProperty;\nvar toString = ref.toString; // Checks if an object has a property.\n\nfunction has(obj, propName) {\n  return hasOwnProperty.call(obj, propName);\n}\n\nvar isArray = Array.isArray || function (obj) {\n  return toString.call(obj) === "[object Array]";\n};\n\nfunction wordsRegexp(words) {\n  return new RegExp("^(?:" + words.replace(/ /g, "|") + ")$");\n} // These are used when `options.locations` is on, for the\n// `startLoc` and `endLoc` properties.\n\n\nvar Position = function Position(line, col) {\n  this.line = line;\n  this.column = col;\n};\n\nexports.Position = Position;\n\nPosition.prototype.offset = function offset(n) {\n  return new Position(this.line, this.column + n);\n};\n\nvar SourceLocation = function SourceLocation(p, start, end) {\n  this.start = start;\n  this.end = end;\n\n  if (p.sourceFile !== null) {\n    this.source = p.sourceFile;\n  }\n}; // The `getLineInfo` function is mostly useful when the\n// `locations` option is off (for performance reasons) and you\n// want to find the line/column position for a given character\n// offset. `input` should be the code string that the offset refers\n// into.\n\n\nexports.SourceLocation = SourceLocation;\n\nfunction getLineInfo(input, offset) {\n  for (var line = 1, cur = 0;;) {\n    lineBreakG.lastIndex = cur;\n    var match = lineBreakG.exec(input);\n\n    if (match && match.index < offset) {\n      ++line;\n      cur = match.index + match[0].length;\n    } else {\n      return new Position(line, offset - cur);\n    }\n  }\n} // A second optional argument can be given to further configure\n// the parser process. These options are recognized:\n\n\nvar defaultOptions = {\n  // `ecmaVersion` indicates the ECMAScript version to parse. Must be\n  // either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018), or 10\n  // (2019). This influences support for strict mode, the set of\n  // reserved words, and support for new syntax features. The default\n  // is 10.\n  ecmaVersion: 10,\n  // `sourceType` indicates the mode the code should be parsed in.\n  // Can be either `"script"` or `"module"`. This influences global\n  // strict mode and parsing of `import` and `export` declarations.\n  sourceType: "script",\n  // `onInsertedSemicolon` can be a callback that will be called\n  // when a semicolon is automatically inserted. It will be passed\n  // the position of the comma as an offset, and if `locations` is\n  // enabled, it is given the location as a `{line, column}` object\n  // as second argument.\n  onInsertedSemicolon: null,\n  // `onTrailingComma` is similar to `onInsertedSemicolon`, but for\n  // trailing commas.\n  onTrailingCo