condenser 0.2 → 0.3

data/lib/condenser/processors/node_modules/@babel/types/lib/asserts/generated/index.js

@@ -58,8 +58,8 @@ exports.assertAssignmentPattern = assertAssignmentPattern;
 exports.assertArrayPattern = assertArrayPattern;
 exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
 exports.assertClassBody = assertClassBody;
-exports.assertClassDeclaration = assertClassDeclaration;
 exports.assertClassExpression = assertClassExpression;
+exports.assertClassDeclaration = assertClassDeclaration;
 exports.assertExportAllDeclaration = assertExportAllDeclaration;
 exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
 exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
@@ -119,6 +119,7 @@ exports.assertOpaqueType = assertOpaqueType;
 exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
 exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
 exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
+exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;
 exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
 exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
 exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
@@ -176,6 +177,8 @@ exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
 exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
 exports.assertPrivateName = assertPrivateName;
 exports.assertBigIntLiteral = assertBigIntLiteral;
+exports.assertRecordExpression = assertRecordExpression;
+exports.assertTupleExpression = assertTupleExpression;
 exports.assertTSParameterProperty = assertTSParameterProperty;
 exports.assertTSDeclareFunction = assertTSDeclareFunction;
 exports.assertTSDeclareMethod = assertTSDeclareMethod;
@@ -516,14 +519,14 @@ function assertClassBody(node, opts = {}) {
   assert("ClassBody", node, opts);
 }
 
-function assertClassDeclaration(node, opts = {}) {
-  assert("ClassDeclaration", node, opts);
-}
-
 function assertClassExpression(node, opts = {}) {
   assert("ClassExpression", node, opts);
 }
 
+function assertClassDeclaration(node, opts = {}) {
+  assert("ClassDeclaration", node, opts);
+}
+
 function assertExportAllDeclaration(node, opts = {}) {
   assert("ExportAllDeclaration", node, opts);
 }
@@ -760,6 +763,10 @@ function assertStringTypeAnnotation(node, opts = {}) {
   assert("StringTypeAnnotation", node, opts);
 }
 
+function assertSymbolTypeAnnotation(node, opts = {}) {
+  assert("SymbolTypeAnnotation", node, opts);
+}
+
 function assertThisTypeAnnotation(node, opts = {}) {
   assert("ThisTypeAnnotation", node, opts);
 }
@@ -988,6 +995,14 @@ function assertBigIntLiteral(node, opts = {}) {
   assert("BigIntLiteral", node, opts);
 }
 
+function assertRecordExpression(node, opts = {}) {
+  assert("RecordExpression", node, opts);
+}
+
+function assertTupleExpression(node, opts = {}) {
+  assert("TupleExpression", node, opts);
+}
+
 function assertTSParameterProperty(node, opts = {}) {
   assert("TSParameterProperty", node, opts);
 }

data/lib/condenser/processors/node_modules/@babel/types/lib/builders/generated/index.js

@@ -58,8 +58,8 @@ exports.assignmentPattern = exports.AssignmentPattern = AssignmentPattern;
 exports.arrayPattern = exports.ArrayPattern = ArrayPattern;
 exports.arrowFunctionExpression = exports.ArrowFunctionExpression = ArrowFunctionExpression;
 exports.classBody = exports.ClassBody = ClassBody;
-exports.classDeclaration = exports.ClassDeclaration = ClassDeclaration;
 exports.classExpression = exports.ClassExpression = ClassExpression;
+exports.classDeclaration = exports.ClassDeclaration = ClassDeclaration;
 exports.exportAllDeclaration = exports.ExportAllDeclaration = ExportAllDeclaration;
 exports.exportDefaultDeclaration = exports.ExportDefaultDeclaration = ExportDefaultDeclaration;
 exports.exportNamedDeclaration = exports.ExportNamedDeclaration = ExportNamedDeclaration;
@@ -119,6 +119,7 @@ exports.opaqueType = exports.OpaqueType = OpaqueType;
 exports.qualifiedTypeIdentifier = exports.QualifiedTypeIdentifier = QualifiedTypeIdentifier;
 exports.stringLiteralTypeAnnotation = exports.StringLiteralTypeAnnotation = StringLiteralTypeAnnotation;
 exports.stringTypeAnnotation = exports.StringTypeAnnotation = StringTypeAnnotation;
+exports.symbolTypeAnnotation = exports.SymbolTypeAnnotation = SymbolTypeAnnotation;
 exports.thisTypeAnnotation = exports.ThisTypeAnnotation = ThisTypeAnnotation;
 exports.tupleTypeAnnotation = exports.TupleTypeAnnotation = TupleTypeAnnotation;
 exports.typeofTypeAnnotation = exports.TypeofTypeAnnotation = TypeofTypeAnnotation;
@@ -176,6 +177,8 @@ exports.exportDefaultSpecifier = exports.ExportDefaultSpecifier = ExportDefaultS
 exports.exportNamespaceSpecifier = exports.ExportNamespaceSpecifier = ExportNamespaceSpecifier;
 exports.privateName = exports.PrivateName = PrivateName;
 exports.bigIntLiteral = exports.BigIntLiteral = BigIntLiteral;
+exports.recordExpression = exports.RecordExpression = RecordExpression;
+exports.tupleExpression = exports.TupleExpression = TupleExpression;
 exports.tSParameterProperty = exports.tsParameterProperty = exports.TSParameterProperty = TSParameterProperty;
 exports.tSDeclareFunction = exports.tsDeclareFunction = exports.TSDeclareFunction = TSDeclareFunction;
 exports.tSDeclareMethod = exports.tsDeclareMethod = exports.TSDeclareMethod = TSDeclareMethod;
@@ -466,14 +469,14 @@ function ClassBody(...args) {
   return (0, _builder.default)("ClassBody", ...args);
 }
 
-function ClassDeclaration(...args) {
-  return (0, _builder.default)("ClassDeclaration", ...args);
-}
-
 function ClassExpression(...args) {
   return (0, _builder.default)("ClassExpression", ...args);
 }
 
+function ClassDeclaration(...args) {
+  return (0, _builder.default)("ClassDeclaration", ...args);
+}
+
 function ExportAllDeclaration(...args) {
   return (0, _builder.default)("ExportAllDeclaration", ...args);
 }
@@ -710,6 +713,10 @@ function StringTypeAnnotation(...args) {
   return (0, _builder.default)("StringTypeAnnotation", ...args);
 }
 
+function SymbolTypeAnnotation(...args) {
+  return (0, _builder.default)("SymbolTypeAnnotation", ...args);
+}
+
 function ThisTypeAnnotation(...args) {
   return (0, _builder.default)("ThisTypeAnnotation", ...args);
 }
@@ -938,6 +945,14 @@ function BigIntLiteral(...args) {
   return (0, _builder.default)("BigIntLiteral", ...args);
 }
 
+function RecordExpression(...args) {
+  return (0, _builder.default)("RecordExpression", ...args);
+}
+
+function TupleExpression(...args) {
+  return (0, _builder.default)("TupleExpression", ...args);
+}
+
 function TSParameterProperty(...args) {
   return (0, _builder.default)("TSParameterProperty", ...args);
 }

data/lib/condenser/processors/node_modules/@babel/types/lib/clone/cloneDeepWithoutLoc.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = cloneDeepWithoutLoc;
+
+var _cloneNode = _interopRequireDefault(require("./cloneNode"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function cloneDeepWithoutLoc(node) {
+  return (0, _cloneNode.default)(node, true, true);
+}

data/lib/condenser/processors/node_modules/@babel/types/lib/clone/cloneNode.js

@@ -9,23 +9,23 @@ var _definitions = require("../definitions");
 
 const has = Function.call.bind(Object.prototype.hasOwnProperty);
 
-function cloneIfNode(obj, deep) {
-  if (obj && typeof obj.type === "string" && obj.type !== "CommentLine" && obj.type !== "CommentBlock") {
-    return cloneNode(obj, deep);
+function cloneIfNode(obj, deep, withoutLoc) {
+  if (obj && typeof obj.type === "string") {
+    return cloneNode(obj, deep, withoutLoc);
   }
 
   return obj;
 }
 
-function cloneIfNodeOrArray(obj, deep) {
+function cloneIfNodeOrArray(obj, deep, withoutLoc) {
   if (Array.isArray(obj)) {
-    return obj.map(node => cloneIfNode(node, deep));
+    return obj.map(node => cloneIfNode(node, deep, withoutLoc));
   }
 
-  return cloneIfNode(obj, deep);
+  return cloneIfNode(obj, deep, withoutLoc);
 }
 
-function cloneNode(node, deep = true) {
+function cloneNode(node, deep = true, withoutLoc = false) {
   if (!node) return node;
   const {
     type
@@ -42,32 +42,40 @@ function cloneNode(node, deep = true) {
     }
 
     if (has(node, "typeAnnotation")) {
-      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true) : node.typeAnnotation;
+      newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc) : node.typeAnnotation;
     }
   } else if (!has(_definitions.NODE_FIELDS, type)) {
     throw new Error(`Unknown node type: "${type}"`);
   } else {
     for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
       if (has(node, field)) {
-        newNode[field] = deep ? cloneIfNodeOrArray(node[field], true) : node[field];
+        if (deep) {
+          newNode[field] = type === "File" && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc) : cloneIfNodeOrArray(node[field], true, withoutLoc);
+        } else {
+          newNode[field] = node[field];
+        }
       }
     }
   }
 
   if (has(node, "loc")) {
-    newNode.loc = node.loc;
+    if (withoutLoc) {
+      newNode.loc = null;
+    } else {
+      newNode.loc = node.loc;
+    }
   }
 
   if (has(node, "leadingComments")) {
-    newNode.leadingComments = node.leadingComments;
+    newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc);
   }
 
   if (has(node, "innerComments")) {
-    newNode.innerComments = node.innerComments;
+    newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc);
   }
 
   if (has(node, "trailingComments")) {
-    newNode.trailingComments = node.trailingComments;
+    newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc);
   }
 
   if (has(node, "extra")) {
@@ -75,4 +83,19 @@ function cloneNode(node, deep = true) {
   }
 
   return newNode;
+}
+
+function cloneCommentsWithoutLoc(comments) {
+  return comments.map(({
+    type,
+    value
+  }) => ({
+    type,
+    value,
+    loc: null
+  }));
+}
+
+function maybeCloneComments(comments, deep, withoutLoc) {
+  return deep && withoutLoc ? cloneCommentsWithoutLoc(comments) : comments;
 }

data/lib/condenser/processors/node_modules/@babel/types/lib/clone/cloneWithoutLoc.js

@@ -5,12 +5,10 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = cloneWithoutLoc;
 
-var _clone = _interopRequireDefault(require("./clone"));
+var _cloneNode = _interopRequireDefault(require("./cloneNode"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function cloneWithoutLoc(node) {
-  const newNode = (0, _clone.default)(node);
-  newNode.loc = null;
-  return newNode;
+  return (0, _cloneNode.default)(node, false, true);
 }

data/lib/condenser/processors/node_modules/@babel/types/lib/constants/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = void 0;
+exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = void 0;
 const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
 exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
 const FLATTENABLE_KEYS = ["body", "expressions"];
@@ -28,6 +28,8 @@ const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>"
 exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
 const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS];
 exports.BINARY_OPERATORS = BINARY_OPERATORS;
+const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
+exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
 const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
 exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
 const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];

data/lib/condenser/processors/node_modules/@babel/types/lib/definitions/core.js

@@ -5,8 +5,12 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0;
 
+var _is = _interopRequireDefault(require("../validators/is"));
+
 var _isValidIdentifier = _interopRequireDefault(require("../validators/isValidIdentifier"));
 
+var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
+
 var _constants = require("../constants");
 
 var _utils = _interopRequireWildcard(require("./utils"));
@@ -21,7 +25,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
   fields: {
     elements: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
-      default: []
+      default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined
     }
   },
   visitor: ["elements"],
@@ -30,10 +34,21 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 (0, _utils.default)("AssignmentExpression", {
   fields: {
     operator: {
-      validate: (0, _utils.assertValueType)("string")
+      validate: function () {
+        if (!process.env.BABEL_TYPES_8_BREAKING) {
+          return (0, _utils.assertValueType)("string");
+        }
+
+        const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS);
+        const pattern = (0, _utils.assertOneOf)("=");
+        return function (node, key, val) {
+          const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier;
+          validator(node, key, val);
+        };
+      }()
     },
     left: {
-      validate: (0, _utils.assertNodeType)("LVal")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
     },
     right: {
       validate: (0, _utils.assertNodeType)("Expression")
@@ -111,17 +126,19 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
   visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
   builder: ["callee", "arguments"],
   aliases: ["Expression"],
-  fields: {
+  fields: Object.assign({
     callee: {
       validate: (0, _utils.assertNodeType)("Expression", "V8IntrinsicIdentifier")
     },
     arguments: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
-    },
+    }
+  }, !process.env.BABEL_TYPES_8_BREAKING ? {
     optional: {
       validate: (0, _utils.assertOneOf)(true, false),
       optional: true
-    },
+    }
+  } : {}, {
     typeArguments: {
       validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
       optional: true
@@ -130,13 +147,13 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
       validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
       optional: true
     }
-  }
+  })
 });
 (0, _utils.default)("CatchClause", {
   visitor: ["param", "body"],
   fields: {
     param: {
-      validate: (0, _utils.assertNodeType)("Identifier"),
+      validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
       optional: true
     },
     body: {
@@ -211,7 +228,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
   aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
   fields: {
     left: {
-      validate: (0, _utils.assertNodeType)("VariableDeclaration", "LVal")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
     },
     right: {
       validate: (0, _utils.assertNodeType)("Expression")
@@ -247,11 +264,9 @@ const functionCommon = {
     validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
   },
   generator: {
-    default: false,
-    validate: (0, _utils.assertValueType)("boolean")
+    default: false
   },
   async: {
-    validate: (0, _utils.assertValueType)("boolean"),
     default: false
   }
 };
@@ -286,7 +301,16 @@ exports.functionDeclarationCommon = functionDeclarationCommon;
       validate: (0, _utils.assertNodeType)("BlockStatement")
     }
   }),
-  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"]
+  aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
+  validate: function () {
+    if (!process.env.BABEL_TYPES_8_BREAKING) return () => {};
+    const identifier = (0, _utils.assertNodeType)("Identifier");
+    return function (parent, key, node) {
+      if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
+        identifier(node, "id", node.id);
+      }
+    };
+  }()
 });
 (0, _utils.default)("FunctionExpression", {
   inherits: "FunctionDeclaration",
@@ -317,15 +341,52 @@ exports.patternLikeCommon = patternLikeCommon;
   aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
   fields: Object.assign({}, patternLikeCommon, {
     name: {
-      validate: (0, _utils.chain)(function (node, key, val) {
-        if (!(0, _isValidIdentifier.default)(val)) {}
-      }, (0, _utils.assertValueType)("string"))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), function (node, key, val) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+        if (!(0, _isValidIdentifier.default)(val, false)) {
+          throw new TypeError(`"${val}" is not a valid identifier name`);
+        }
+      })
     },
     optional: {
       validate: (0, _utils.assertValueType)("boolean"),
       optional: true
     }
-  })
+  }),
+
+  validate(parent, key, node) {
+    if (!process.env.BABEL_TYPES_8_BREAKING) return;
+    const match = /\.(\w+)$/.exec(key);
+    if (!match) return;
+    const [, parentKey] = match;
+    const nonComp = {
+      computed: false
+    };
+
+    if (parentKey === "property") {
+      if ((0, _is.default)("MemberExpression", parent, nonComp)) return;
+      if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return;
+    } else if (parentKey === "key") {
+      if ((0, _is.default)("Property", parent, nonComp)) return;
+      if ((0, _is.default)("Method", parent, nonComp)) return;
+    } else if (parentKey === "exported") {
+      if ((0, _is.default)("ExportSpecifier", parent)) return;
+    } else if (parentKey === "imported") {
+      if ((0, _is.default)("ImportSpecifier", parent, {
+        imported: node
+      })) return;
+    } else if (parentKey === "meta") {
+      if ((0, _is.default)("MetaProperty", parent, {
+        meta: node
+      })) return;
+    }
+
+    if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name)) && node.name !== "this") {
+      throw new TypeError(`"${node.name}" is not a valid identifier`);
+    }
+  }
+
 });
 (0, _utils.default)("IfStatement", {
   visitor: ["test", "consequent", "alternate"],
@@ -389,13 +450,20 @@ exports.patternLikeCommon = patternLikeCommon;
 (0, _utils.default)("RegExpLiteral", {
   builder: ["pattern", "flags"],
   deprecatedAlias: "RegexLiteral",
-  aliases: ["Expression", "Literal"],
+  aliases: ["Expression", "Pureish", "Literal"],
   fields: {
     pattern: {
       validate: (0, _utils.assertValueType)("string")
     },
     flags: {
-      validate: (0, _utils.assertValueType)("string"),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), function (node, key, val) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+        const invalid = /[^gimsuy]/.exec(val);
+
+        if (invalid) {
+          throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
+        }
+      }),
       default: ""
     }
   }
@@ -420,7 +488,7 @@ exports.patternLikeCommon = patternLikeCommon;
   builder: ["object", "property", "computed", "optional"],
   visitor: ["object", "property"],
   aliases: ["Expression", "LVal"],
-  fields: {
+  fields: Object.assign({
     object: {
       validate: (0, _utils.assertNodeType)("Expression")
     },
@@ -436,12 +504,13 @@ exports.patternLikeCommon = patternLikeCommon;
     },
     computed: {
       default: false
-    },
+    }
+  }, !process.env.BABEL_TYPES_8_BREAKING ? {
     optional: {
       validate: (0, _utils.assertOneOf)(true, false),
       optional: true
     }
-  }
+  } : {})
 });
 (0, _utils.default)("NewExpression", {
   inherits: "CallExpression"
@@ -482,14 +551,14 @@ exports.patternLikeCommon = patternLikeCommon;
   }
 });
 (0, _utils.default)("ObjectMethod", {
-  builder: ["kind", "key", "params", "body", "computed"],
+  builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
   fields: Object.assign({}, functionCommon, {}, functionTypeAnnotationCommon, {
-    kind: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("method", "get", "set")),
+    kind: Object.assign({
+      validate: (0, _utils.assertOneOf)("method", "get", "set")
+    }, !process.env.BABEL_TYPES_8_BREAKING ? {
       default: "method"
-    },
+    } : {}),
     computed: {
-      validate: (0, _utils.assertValueType)("boolean"),
       default: false
     },
     key: {
@@ -503,7 +572,8 @@ exports.patternLikeCommon = patternLikeCommon;
       }()
     },
     decorators: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
+      optional: true
     },
     body: {
       validate: (0, _utils.assertNodeType)("BlockStatement")
@@ -513,10 +583,9 @@ exports.patternLikeCommon = patternLikeCommon;
   aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
 });
 (0, _utils.default)("ObjectProperty", {
-  builder: ["key", "value", "computed", "shorthand", "decorators"],
+  builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])],
   fields: {
     computed: {
-      validate: (0, _utils.assertValueType)("boolean"),
       default: false
     },
     key: {
@@ -533,7 +602,19 @@ exports.patternLikeCommon = patternLikeCommon;
       validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
     },
     shorthand: {
-      validate: (0, _utils.assertValueType)("boolean"),
+      validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), function (node, key, val) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+        if (val && node.computed) {
+          throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
+        }
+      }, function (node, key, val) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+        if (val && !(0, _is.default)("Identifier", node.key)) {
+          throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
+        }
+      }),
       default: false
     },
     decorators: {
@@ -542,7 +623,16 @@ exports.patternLikeCommon = patternLikeCommon;
     }
   },
   visitor: ["key", "value", "decorators"],
-  aliases: ["UserWhitespacable", "Property", "ObjectMember"]
+  aliases: ["UserWhitespacable", "Property", "ObjectMember"],
+  validate: function () {
+    const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern");
+    const expression = (0, _utils.assertNodeType)("Expression");
+    return function (parent, key, node) {
+      if (!process.env.BABEL_TYPES_8_BREAKING) return;
+      const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression;
+      validator(node, "value", node.value);
+    };
+  }()
 });
 (0, _utils.default)("RestElement", {
   visitor: ["argument", "typeAnnotation"],
@@ -551,9 +641,21 @@ exports.patternLikeCommon = patternLikeCommon;
   deprecatedAlias: "RestProperty",
   fields: Object.assign({}, patternLikeCommon, {
     argument: {
-      validate: (0, _utils.assertNodeType)("LVal")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "Pattern", "MemberExpression")
     }
-  })
+  }),
+
+  validate(parent, key) {
+    if (!process.env.BABEL_TYPES_8_BREAKING) return;
+    const match = /(\w+)\[(\d+)\]/.exec(key);
+    if (!match) throw new Error("Internal Babel error: malformed key.");
+    const [, listKey, index] = match;
+
+    if (parent[listKey].length > index + 1) {
+      throw new TypeError(`RestElement must be last element of ${listKey}`);
+    }
+  }
+
 });
 (0, _utils.default)("ReturnStatement", {
   visitor: ["argument"],
@@ -624,7 +726,13 @@ exports.patternLikeCommon = patternLikeCommon;
   aliases: ["Statement"],
   fields: {
     block: {
-      validate: (0, _utils.assertNodeType)("BlockStatement")
+      validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), function (node) {
+        if (!process.env.BABEL_TYPES_8_BREAKING) return;
+
+        if (!node.handler && !node.finalizer) {
+          throw new TypeError("TryStatement expects either a handler or finalizer, or both");
+        }
+      })
     },
     handler: {
       optional: true,
@@ -659,7 +767,7 @@ exports.patternLikeCommon = patternLikeCommon;
       default: false
     },
     argument: {
-      validate: (0, _utils.assertNodeType)("Expression")
+      validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression")
     },
     operator: {
       validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
@@ -678,18 +786,41 @@ exports.patternLikeCommon = patternLikeCommon;
       optional: true
     },
     kind: {
-      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("var", "let", "const"))
+      validate: (0, _utils.assertOneOf)("var", "let", "const")
     },
     declarations: {
       validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
     }
+  },
+
+  validate(parent, key, node) {
+    if (!process.env.BABEL_TYPES_8_BREAKING) return;
+    if (!(0, _is.default)("ForXStatement", parent, {
+      left: node
+    })) return;
+
+    if (node.declarations.length !== 1) {
+      throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);
+    }
   }
+
 });
 (0, _utils.default)("VariableDeclarator", {
   visitor: ["id", "init"],
   fields: {
     id: {
-      validate: (0, _utils.assertNodeType)("LVal")
+      validate: function () {
+        if (!process.env.BABEL_TYPES_8_BREAKING) {
+          return (0, _utils.assertNodeType)("LVal");
+        }
+
+        const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern");
+        const without = (0, _utils.assertNodeType)("Identifier");
+        return function (node, key, val) {
+          const validator = node.init ? normal : without;
+          validator(node, key, val);
+        };
+      }()
     },
     definite: {
       optional: true,
@@ -709,7 +840,7 @@ exports.patternLikeCommon = patternLikeCommon;
       validate: (0, _utils.assertNodeType)("Expression")
     },
     body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement", "Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
   }
 });
@@ -721,7 +852,7 @@ exports.patternLikeCommon = patternLikeCommon;
       validate: (0, _utils.assertNodeType)("Expression")
     },
     body: {
-      validate: (0, _utils.assertNodeType)("BlockStatement", "Statement")
+      validate: (0, _utils.assertNodeType)("Statement")
     }
   }
 });