astexplorer.app/vendor/astexplorer/out/17.js

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

(window.webpackJsonp=window.webpackJsonp||[]).push([[17,87],{"./node_modules/ansi-regex/index.js":function(module,exports,__webpack_require__){"use strict";eval("\nmodule.exports = function () {\n\treturn /[\\u001b\\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-PRZcf-nqry=><]/g;\n};\n\n\n//# sourceURL=webpack:///./node_modules/ansi-regex/index.js?")},"./node_modules/assert/assert.js":function(module,exports,__webpack_require__){"use strict";eval("/* WEBPACK VAR INJECTION */(function(global) {\n\nvar objectAssign = __webpack_require__(\"./node_modules/object-assign/index.js\");\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n//     node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = __webpack_require__(\"./node_modules/util/util.js\");\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n  if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n  equal: assert.strictEqual,\n  deepEqual: assert.deepStrictEqual,\n  notEqual: assert.notStrictEqual,\n  notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n\n/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(\"./node_modules/webpack/buildin/global.js\")))\n\n//# sourceURL=webpack:///./node_modules/assert/assert.js?")},"./node_modules/ast-types/def/babel-core.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar es_proposals_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/es-proposals.js"));\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nvar shared_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/shared.js"));\n\nfunction default_1(fork) {\n  fork.use(es_proposals_1.default);\n  var types = fork.use(types_1.default);\n  var defaults = fork.use(shared_1.default).defaults;\n  var def = types.Type.def;\n  var or = types.Type.or;\n  def("Noop").bases("Statement").build();\n  def("DoExpression").bases("Expression").build("body").field("body", [def("Statement")]);\n  def("BindExpression").bases("Expression").build("object", "callee").field("object", or(def("Expression"), null)).field("callee", def("Expression"));\n  def("ParenthesizedExpression").bases("Expression").build("expression").field("expression", def("Expression"));\n  def("ExportNamespaceSpecifier").bases("Specifier").build("exported").field("exported", def("Identifier"));\n  def("ExportDefaultSpecifier").bases("Specifier").build("exported").field("exported", def("Identifier"));\n  def("CommentBlock").bases("Comment").build("value",\n  /*optional:*/\n  "leading", "trailing");\n  def("CommentLine").bases("Comment").build("value",\n  /*optional:*/\n  "leading", "trailing");\n  def("Directive").bases("Node").build("value").field("value", def("DirectiveLiteral"));\n  def("DirectiveLiteral").bases("Node", "Expression").build("value").field("value", String, defaults["use strict"]);\n  def("InterpreterDirective").bases("Node").build("value").field("value", String);\n  def("BlockStatement").bases("Statement").build("body").field("body", [def("Statement")]).field("directives", [def("Directive")], defaults.emptyArray);\n  def("Program").bases("Node").build("body").field("body", [def("Statement")]).field("directives", [def("Directive")], defaults.emptyArray).field("interpreter", or(def("InterpreterDirective"), null), defaults["null"]); // Split Literal\n\n  def("StringLiteral").bases("Literal").build("value").field("value", String);\n  def("NumericLiteral").bases("Literal").build("value").field("value", Number).field("raw", or(String, null), defaults["null"]).field("extra", {\n    rawValue: Number,\n    raw: String\n  }, function getDefault() {\n    return {\n      rawValue: this.value,\n      raw: this.value + ""\n    };\n  });\n  def("BigIntLiteral").bases("Literal").build("value") // Only String really seems appropriate here, since BigInt values\n  // often exceed the limits of JS numbers.\n  .field("value", or(String, Number)).field("extra", {\n    rawValue: String,\n    raw: String\n  }, function getDefault() {\n    return {\n      rawValue: String(this.value),\n      raw: this.value + "n"\n    };\n  });\n  def("NullLiteral").bases("Literal").build().field("value", null, defaults["null"]);\n  def("BooleanLiteral").bases("Literal").build("value").field("value", Boolean);\n  def("RegExpLiteral").bases("Literal").build("pattern", "flags").field("pattern", String).field("flags", String).field("value", RegExp, function () {\n    return new RegExp(this.pattern, this.flags);\n  });\n  var ObjectExpressionProperty = or(def("Property"), def("ObjectMethod"), def("ObjectProperty"), def("SpreadProperty"), def("SpreadElement")); // Split Property -> ObjectProperty and ObjectMethod\n\n  def("ObjectExpression").bases("Expression").build("properties").field("properties", [ObjectExpressionProperty]); // ObjectMethod hoist .value properties to own properties\n\n  def("ObjectMethod").bases("Node", "Function").build("kind", "key", "params", "body", "computed").field("kind", or("method", "get", "set")).field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("params", [def("Pattern")]).field("body", def("BlockStatement")).field("computed", Boolean, defaults["false"]).field("generator", Boolean, defaults["false"]).field("async", Boolean, defaults["false"]).field("accessibility", // TypeScript\n  or(def("Literal"), null), defaults["null"]).field("decorators", or([def("Decorator")], null), defaults["null"]);\n  def("ObjectProperty").bases("Node").build("key", "value").field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("value", or(def("Expression"), def("Pattern"))).field("accessibility", // TypeScript\n  or(def("Literal"), null), defaults["null"]).field("computed", Boolean, defaults["false"]);\n  var ClassBodyElement = or(def("MethodDefinition"), def("VariableDeclarator"), def("ClassPropertyDefinition"), def("ClassProperty"), def("ClassPrivateProperty"), def("ClassMethod"), def("ClassPrivateMethod")); // MethodDefinition -> ClassMethod\n\n  def("ClassBody").bases("Declaration").build("body").field("body", [ClassBodyElement]);\n  def("ClassMethod").bases("Declaration", "Function").build("kind", "key", "params", "body", "computed", "static").field("key", or(def("Literal"), def("Identifier"), def("Expression")));\n  def("ClassPrivateMethod").bases("Declaration", "Function").build("key", "params", "body", "kind", "computed", "static").field("key", def("PrivateName"));\n  ["ClassMethod", "ClassPrivateMethod"].forEach(function (typeName) {\n    def(typeName).field("kind", or("get", "set", "method", "constructor"), function () {\n      return "method";\n    }).field("body", def("BlockStatement")).field("computed", Boolean, defaults["false"]).field("static", or(Boolean, null), defaults["null"]).field("abstract", or(Boolean, null), defaults["null"]).field("access", or("public", "private", "protected", null), defaults["null"]).field("accessibility", or("public", "private", "protected", null), defaults["null"]).field("decorators", or([def("Decorator")], null), defaults["null"]).field("optional", or(Boolean, null), defaults["null"]);\n  });\n  var ObjectPatternProperty = or(def("Property"), def("PropertyPattern"), def("SpreadPropertyPattern"), def("SpreadProperty"), // Used by Esprima\n  def("ObjectProperty"), // Babel 6\n  def("RestProperty") // Babel 6\n  ); // Split into RestProperty and SpreadProperty\n\n  def("ObjectPattern").bases("Pattern").build("properties").field("properties", [ObjectPatternProperty]).field("decorators", or([def("Decorator")], null), defaults["null"]);\n  def("SpreadProperty").bases("Node").build("argument").field("argument", def("Expression"));\n  def("RestProperty").bases("Node").build("argument").field("argument", def("Expression"));\n  def("ForAwaitStatement").bases("Statement").build("left", "right", "body").field("left", or(def("VariableDeclaration"), def("Expression"))).field("right", def("Expression")).field("body", def("Statement")); // The callee node of a dynamic import(...) expression.\n\n  def("Import").bases("Expression").build();\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/babel-core.js?')},"./node_modules/ast-types/def/babel.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar babel_core_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/babel-core.js"));\n\nvar flow_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/flow.js"));\n\nfunction default_1(fork) {\n  fork.use(babel_core_1.default);\n  fork.use(flow_1.default);\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/babel.js?')},"./node_modules/ast-types/def/core-operators.js":function(module,exports,__webpack_require__){"use strict";eval('\n\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\nexports.LogicalOperators = exports.AssignmentOperators = exports.BinaryOperators = void 0;\nexports.BinaryOperators = ["==", "!=", "===", "!==", "<", "<=", ">", ">=", "<<", ">>", ">>>", "+", "-", "*", "/", "%", "&", "|", "^", "in", "instanceof"];\nexports.AssignmentOperators = ["=", "+=", "-=", "*=", "/=", "%=", "<<=", ">>=", ">>>=", "|=", "^=", "&="];\nexports.LogicalOperators = ["||", "&&"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/core-operators.js?')},"./node_modules/ast-types/def/core.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar core_operators_1 = __webpack_require__("./node_modules/ast-types/def/core-operators.js");\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nvar shared_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/shared.js"));\n\nfunction default_1(fork) {\n  var types = fork.use(types_1.default);\n  var Type = types.Type;\n  var def = Type.def;\n  var or = Type.or;\n  var shared = fork.use(shared_1.default);\n  var defaults = shared.defaults;\n  var geq = shared.geq; // Abstract supertype of all syntactic entities that are allowed to have a\n  // .loc field.\n\n  def("Printable").field("loc", or(def("SourceLocation"), null), defaults["null"], true);\n  def("Node").bases("Printable").field("type", String).field("comments", or([def("Comment")], null), defaults["null"], true);\n  def("SourceLocation").field("start", def("Position")).field("end", def("Position")).field("source", or(String, null), defaults["null"]);\n  def("Position").field("line", geq(1)).field("column", geq(0));\n  def("File").bases("Node").build("program", "name").field("program", def("Program")).field("name", or(String, null), defaults["null"]);\n  def("Program").bases("Node").build("body").field("body", [def("Statement")]);\n  def("Function").bases("Node").field("id", or(def("Identifier"), null), defaults["null"]).field("params", [def("Pattern")]).field("body", def("BlockStatement")).field("generator", Boolean, defaults["false"]).field("async", Boolean, defaults["false"]);\n  def("Statement").bases("Node"); // The empty .build() here means that an EmptyStatement can be constructed\n  // (i.e. it\'s not abstract) but that it needs no arguments.\n\n  def("EmptyStatement").bases("Statement").build();\n  def("BlockStatement").bases("Statement").build("body").field("body", [def("Statement")]); // TODO Figure out how to silently coerce Expressions to\n  // ExpressionStatements where a Statement was expected.\n\n  def("ExpressionStatement").bases("Statement").build("expression").field("expression", def("Expression"));\n  def("IfStatement").bases("Statement").build("test", "consequent", "alternate").field("test", def("Expression")).field("consequent", def("Statement")).field("alternate", or(def("Statement"), null), defaults["null"]);\n  def("LabeledStatement").bases("Statement").build("label", "body").field("label", def("Identifier")).field("body", def("Statement"));\n  def("BreakStatement").bases("Statement").build("label").field("label", or(def("Identifier"), null), defaults["null"]);\n  def("ContinueStatement").bases("Statement").build("label").field("label", or(def("Identifier"), null), defaults["null"]);\n  def("WithStatement").bases("Statement").build("object", "body").field("object", def("Expression")).field("body", def("Statement"));\n  def("SwitchStatement").bases("Statement").build("discriminant", "cases", "lexical").field("discriminant", def("Expression")).field("cases", [def("SwitchCase")]).field("lexical", Boolean, defaults["false"]);\n  def("ReturnStatement").bases("Statement").build("argument").field("argument", or(def("Expression"), null));\n  def("ThrowStatement").bases("Statement").build("argument").field("argument", def("Expression"));\n  def("TryStatement").bases("Statement").build("block", "handler", "finalizer").field("block", def("BlockStatement")).field("handler", or(def("CatchClause"), null), function () {\n    return this.handlers && this.handlers[0] || null;\n  }).field("handlers", [def("CatchClause")], function () {\n    return this.handler ? [this.handler] : [];\n  }, true) // Indicates this field is hidden from eachField iteration.\n  .field("guardedHandlers", [def("CatchClause")], defaults.emptyArray).field("finalizer", or(def("BlockStatement"), null), defaults["null"]);\n  def("CatchClause").bases("Node").build("param", "guard", "body").field("param", def("Pattern")).field("guard", or(def("Expression"), null), defaults["null"]).field("body", def("BlockStatement"));\n  def("WhileStatement").bases("Statement").build("test", "body").field("test", def("Expression")).field("body", def("Statement"));\n  def("DoWhileStatement").bases("Statement").build("body", "test").field("body", def("Statement")).field("test", def("Expression"));\n  def("ForStatement").bases("Statement").build("init", "test", "update", "body").field("init", or(def("VariableDeclaration"), def("Expression"), null)).field("test", or(def("Expression"), null)).field("update", or(def("Expression"), null)).field("body", def("Statement"));\n  def("ForInStatement").bases("Statement").build("left", "right", "body").field("left", or(def("VariableDeclaration"), def("Expression"))).field("right", def("Expression")).field("body", def("Statement"));\n  def("DebuggerStatement").bases("Statement").build();\n  def("Declaration").bases("Statement");\n  def("FunctionDeclaration").bases("Function", "Declaration").build("id", "params", "body").field("id", def("Identifier"));\n  def("FunctionExpression").bases("Function", "Expression").build("id", "params", "body");\n  def("VariableDeclaration").bases("Declaration").build("kind", "declarations").field("kind", or("var", "let", "const")).field("declarations", [def("VariableDeclarator")]);\n  def("VariableDeclarator").bases("Node").build("id", "init").field("id", def("Pattern")).field("init", or(def("Expression"), null), defaults["null"]);\n  def("Expression").bases("Node");\n  def("ThisExpression").bases("Expression").build();\n  def("ArrayExpression").bases("Expression").build("elements").field("elements", [or(def("Expression"), null)]);\n  def("ObjectExpression").bases("Expression").build("properties").field("properties", [def("Property")]); // TODO Not in the Mozilla Parser API, but used by Esprima.\n\n  def("Property").bases("Node") // Want to be able to visit Property Nodes.\n  .build("kind", "key", "value").field("kind", or("init", "get", "set")).field("key", or(def("Literal"), def("Identifier"))).field("value", def("Expression"));\n  def("SequenceExpression").bases("Expression").build("expressions").field("expressions", [def("Expression")]);\n  var UnaryOperator = or("-", "+", "!", "~", "typeof", "void", "delete");\n  def("UnaryExpression").bases("Expression").build("operator", "argument", "prefix").field("operator", UnaryOperator).field("argument", def("Expression")) // Esprima doesn\'t bother with this field, presumably because it\'s\n  // always true for unary operators.\n  .field("prefix", Boolean, defaults["true"]);\n  var BinaryOperator = or.apply(void 0, core_operators_1.BinaryOperators);\n  def("BinaryExpression").bases("Expression").build("operator", "left", "right").field("operator", BinaryOperator).field("left", def("Expression")).field("right", def("Expression"));\n  var AssignmentOperator = or.apply(void 0, core_operators_1.AssignmentOperators);\n  def("AssignmentExpression").bases("Expression").build("operator", "left", "right").field("operator", AssignmentOperator).field("left", or(def("Pattern"), def("MemberExpression"))).field("right", def("Expression"));\n  var UpdateOperator = or("++", "--");\n  def("UpdateExpression").bases("Expression").build("operator", "argument", "prefix").field("operator", UpdateOperator).field("argument", def("Expression")).field("prefix", Boolean);\n  var LogicalOperator = or.apply(void 0, core_operators_1.LogicalOperators);\n  def("LogicalExpression").bases("Expression").build("operator", "left", "right").field("operator", LogicalOperator).field("left", def("Expression")).field("right", def("Expression"));\n  def("ConditionalExpression").bases("Expression").build("test", "consequent", "alternate").field("test", def("Expression")).field("consequent", def("Expression")).field("alternate", def("Expression"));\n  def("NewExpression").bases("Expression").build("callee", "arguments").field("callee", def("Expression")) // The Mozilla Parser API gives this type as [or(def("Expression"),\n  // null)], but null values don\'t really make sense at the call site.\n  // TODO Report this nonsense.\n  .field("arguments", [def("Expression")]);\n  def("CallExpression").bases("Expression").build("callee", "arguments").field("callee", def("Expression")) // See comment for NewExpression above.\n  .field("arguments", [def("Expression")]);\n  def("MemberExpression").bases("Expression").build("object", "property", "computed").field("object", def("Expression")).field("property", or(def("Identifier"), def("Expression"))).field("computed", Boolean, function () {\n    var type = this.property.type;\n\n    if (type === \'Literal\' || type === \'MemberExpression\' || type === \'BinaryExpression\') {\n      return true;\n    }\n\n    return false;\n  });\n  def("Pattern").bases("Node");\n  def("SwitchCase").bases("Node").build("test", "consequent").field("test", or(def("Expression"), null)).field("consequent", [def("Statement")]);\n  def("Identifier").bases("Expression", "Pattern").build("name").field("name", String).field("optional", Boolean, defaults["false"]);\n  def("Literal").bases("Expression").build("value").field("value", or(String, Boolean, null, Number, RegExp)).field("regex", or({\n    pattern: String,\n    flags: String\n  }, null), function () {\n    if (this.value instanceof RegExp) {\n      var flags = "";\n      if (this.value.ignoreCase) flags += "i";\n      if (this.value.multiline) flags += "m";\n      if (this.value.global) flags += "g";\n      return {\n        pattern: this.value.source,\n        flags: flags\n      };\n    }\n\n    return null;\n  }); // Abstract (non-buildable) comment supertype. Not a Node.\n\n  def("Comment").bases("Printable").field("value", String) // A .leading comment comes before the node, whereas a .trailing\n  // comment comes after it. These two fields should not both be true,\n  // but they might both be false when the comment falls inside a node\n  // and the node has no children for the comment to lead or trail,\n  // e.g. { /*dangling*/ }.\n  .field("leading", Boolean, defaults["true"]).field("trailing", Boolean, defaults["false"]);\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/core.js?')},"./node_modules/ast-types/def/es-proposals.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nvar shared_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/shared.js"));\n\nvar es2020_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/es2020.js"));\n\nfunction default_1(fork) {\n  fork.use(es2020_1.default);\n  var types = fork.use(types_1.default);\n  var Type = types.Type;\n  var def = types.Type.def;\n  var or = Type.or;\n  var shared = fork.use(shared_1.default);\n  var defaults = shared.defaults;\n  def("AwaitExpression").build("argument", "all").field("argument", or(def("Expression"), null)).field("all", Boolean, defaults["false"]); // Decorators\n\n  def("Decorator").bases("Node").build("expression").field("expression", def("Expression"));\n  def("Property").field("decorators", or([def("Decorator")], null), defaults["null"]);\n  def("MethodDefinition").field("decorators", or([def("Decorator")], null), defaults["null"]); // Private names\n\n  def("PrivateName").bases("Expression", "Pattern").build("id").field("id", def("Identifier"));\n  def("ClassPrivateProperty").bases("ClassProperty").build("key", "value").field("key", def("PrivateName")).field("value", or(def("Expression"), null), defaults["null"]);\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/es-proposals.js?')},"./node_modules/ast-types/def/es2016.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar core_operators_1 = __webpack_require__("./node_modules/ast-types/def/core-operators.js");\n\nvar es6_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/es6.js"));\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nfunction default_1(fork) {\n  fork.use(es6_1.default);\n  var types = fork.use(types_1.default);\n  var def = types.Type.def;\n  var or = types.Type.or;\n  var BinaryOperator = or.apply(void 0, tslib_1.__spreadArrays(core_operators_1.BinaryOperators, ["**"]));\n  def("BinaryExpression").field("operator", BinaryOperator);\n  var AssignmentOperator = or.apply(void 0, tslib_1.__spreadArrays(core_operators_1.AssignmentOperators, ["**="]));\n  def("AssignmentExpression").field("operator", AssignmentOperator);\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/es2016.js?')},"./node_modules/ast-types/def/es2017.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar es2016_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/es2016.js"));\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nvar shared_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/shared.js"));\n\nfunction default_1(fork) {\n  fork.use(es2016_1.default);\n  var types = fork.use(types_1.default);\n  var def = types.Type.def;\n  var defaults = fork.use(shared_1.default).defaults;\n  def("Function").field("async", Boolean, defaults["false"]);\n  def("AwaitExpression").bases("Expression").build("argument").field("argument", def("Expression"));\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/es2017.js?')},"./node_modules/ast-types/def/es2018.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar es2017_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/es2017.js"));\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nvar shared_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/shared.js"));\n\nfunction default_1(fork) {\n  fork.use(es2017_1.default);\n  var types = fork.use(types_1.default);\n  var def = types.Type.def;\n  var or = types.Type.or;\n  var defaults = fork.use(shared_1.default).defaults;\n  def("ForOfStatement").field("await", Boolean, defaults["false"]); // Legacy\n\n  def("SpreadProperty").bases("Node").build("argument").field("argument", def("Expression"));\n  def("ObjectExpression").field("properties", [or(def("Property"), def("SpreadProperty"), // Legacy\n  def("SpreadElement"))]);\n  def("TemplateElement").field("value", {\n    "cooked": or(String, null),\n    "raw": String\n  }); // Legacy\n\n  def("SpreadPropertyPattern").bases("Pattern").build("argument").field("argument", def("Pattern"));\n  def("ObjectPattern").field("properties", [or(def("PropertyPattern"), def("Property"), def("RestElement"), def("SpreadPropertyPattern"))]);\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/es2018.js?')},"./node_modules/ast-types/def/es2019.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar es2018_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/es2018.js"));\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nvar shared_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/shared.js"));\n\nfunction default_1(fork) {\n  fork.use(es2018_1.default);\n  var types = fork.use(types_1.default);\n  var def = types.Type.def;\n  var or = types.Type.or;\n  var defaults = fork.use(shared_1.default).defaults;\n  def("CatchClause").field("param", or(def("Pattern"), null), defaults["null"]);\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/es2019.js?')},"./node_modules/ast-types/def/es2020.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar core_operators_1 = __webpack_require__("./node_modules/ast-types/def/core-operators.js");\n\nvar es2019_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/es2019.js"));\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nvar shared_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/shared.js"));\n\nfunction default_1(fork) {\n  fork.use(es2019_1.default);\n  var types = fork.use(types_1.default);\n  var def = types.Type.def;\n  var or = types.Type.or;\n  var shared = fork.use(shared_1.default);\n  var defaults = shared.defaults;\n  def("ImportExpression").bases("Expression").build("source").field("source", def("Expression"));\n  def("ExportAllDeclaration").build("source", "exported").field("source", def("Literal")).field("exported", or(def("Identifier"), null)); // Optional chaining\n\n  def("OptionalMemberExpression").bases("MemberExpression").build("object", "property", "computed", "optional").field("optional", Boolean, defaults["true"]);\n  def("OptionalCallExpression").bases("CallExpression").build("callee", "arguments", "optional").field("optional", Boolean, defaults["true"]); // Nullish coalescing\n\n  var LogicalOperator = or.apply(void 0, tslib_1.__spreadArrays(core_operators_1.LogicalOperators, ["??"]));\n  def("LogicalExpression").field("operator", LogicalOperator);\n}\n\nexports.default = default_1;\nmodule.exports = exports["default"];\n\n//# sourceURL=webpack:///./node_modules/ast-types/def/es2020.js?')},"./node_modules/ast-types/def/es6.js":function(module,exports,__webpack_require__){"use strict";eval('\n\n;\nObject.defineProperty(exports, "__esModule", {\n  value: true\n});\n\nvar tslib_1 = __webpack_require__("./node_modules/ast-types/node_modules/tslib/tslib.es6.js");\n\nvar core_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/def/core.js"));\n\nvar types_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/types.js"));\n\nvar shared_1 = tslib_1.__importDefault(__webpack_require__("./node_modules/ast-types/lib/shared.js"));\n\nfunction default_1(fork) {\n  fork.use(core_1.default);\n  var types = fork.use(types_1.default);\n  var def = types.Type.def;\n  var or = types.Type.or;\n  var defaults = fork.use(shared_1.default).defaults;\n  def("Function").field("generator", Boolean, defaults["false"]).field("expression", Boolean, defaults["false"]).field("defaults", [or(def("Expression"), null)], defaults.emptyArray) // Legacy\n  .field("rest", or(def("Identifier"), null), defaults["null"]); // The ESTree way of representing a ...rest parameter.\n\n  def("RestElement").bases("Pattern").build("argument").field("argument", def("Pattern")).field("typeAnnotation", // for Babylon. Flow parser puts it on the identifier\n  or(def("TypeAnnotation"), def("TSTypeAnnotation"), null), defaults["null"]);\n  def("SpreadElementPattern").bases("Pattern").build("argument").field("argument", def("Pattern"));\n  def("FunctionDeclaration").build("id", "params", "body", "generator", "expression") // May be `null` in the context of `export default function () {}`\n  .field("id", or(def("Identifier"), null));\n  def("FunctionExpression").build("id", "params", "body", "generator", "expression");\n  def("ArrowFunctionExpression").bases("Function", "Expression").build("params", "body", "expression") // The forced null value here is compatible with the overridden\n  // definition of the "id" field in the Function interface.\n  .field("id", null, defaults["null"]) // Arrow function bodies are allowed to be expressions.\n  .field("body", or(def("BlockStatement"), def("Expression"))) // The current spec forbids arrow generators, so I have taken the\n  // liberty of enforcing that. TODO Report this.\n  .field("generator", false, defaults["false"]);\n  def("ForOfStatement").bases("Statement").build("left", "right", "body").field("left", or(def("VariableDeclaration"), def("Pattern"))).field("right", def("Expression")).field("body", def("Statement"));\n  def("YieldExpression").bases("Expression").build("argument", "delegate").field("argument", or(def("Expression"), null)).field("delegate", Boolean, defaults["false"]);\n  def("GeneratorExpression").bases("Expression").build("body", "blocks", "filter").field("body", def("Expression")).field("blocks", [def("ComprehensionBlock")]).field("filter", or(def("Expression"), null));\n  def("ComprehensionExpression").bases("Expression").build("body", "blocks", "filter").field("body", def("Expression")).field("blocks", [def("ComprehensionBlock")]).field("filter", or(def("Expression"), null));\n  def("ComprehensionBlock").bases("Node").build("left", "right", "each").field("left", def("Pattern")).field("right", def("Expression")).field("each", Boolean);\n  def("Property").field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("value", or(def("Expression"), def("Pattern"))).field("method", Boolean, defaults["false"]).field("shorthand", Boolean, defaults["false"]).field("computed", Boolean, defaults["false"]);\n  def("ObjectProperty").field("shorthand", Boolean, defaults["false"]);\n  def("PropertyPattern").bases("Pattern").build("key", "pattern").field("key", or(def("Literal"), def("Identifier"), def("Expression"))).field("pattern", def("Pattern")).field("computed", Boolean, defaults["false"]);\n  def("ObjectPattern").bases("Pattern").build("properties").field("properties", [or(def("PropertyPattern"), def("Property"))]);\n  def("ArrayPattern").bases("Pattern").build("elements").field("elements", [or(def("Pattern"), null)]);\n  def("SpreadElement").bases("Node").build("argument").field("argument", def("Expression"));\n  def("ArrayExpression").field("elements", [or(def("Expression"), def("SpreadElement"), def("RestElement"), null)]);\n  def("NewExpression").field("arguments", [or(def("Expression"), def("SpreadElement"))]);\n  def("CallExpression").field("arguments", [or(def("Expression"), def("SpreadElement"))]); // Note: this node type is *not* an AssignmentExpression with a Pattern on\n  // the left-hand side! The existing AssignmentExpression type already\n  // supports destructuring assignments. AssignmentPattern nodes may appear\n  // wherever a Pattern is allowed, and the right-hand side represents a\n  // default value to be destructured against the left-hand side, if no\n  // value is otherwise provided. For example: default parameter values.\n\n  def("AssignmentPattern").bases("Pattern").build("left", "right").field("left", def("Pattern")).field("right", def("Expression"));\n  def("MethodDefinition").bases("Declaration").build("kind", "key", "value", "static").field("kind", o