flow-api-translator 0.37.0 → 0.328.0

package/dist/src/flowDefToTSDef.js

@@ -4,25 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.flowDefToTSDef = flowDefToTSDef;
-
-var FlowESTree = _interopRequireWildcard(require("hermes-estree"));
-
+var FlowESTree = _interopRequireWildcard(require("flow-estree"));
 var TSESTree = _interopRequireWildcard(require("./utils/ts-estree-ast-types"));
-
-var _hermesTransform = require("hermes-transform");
-
+var _flowTransform = require("flow-transform");
 var _ErrorUtils = require("./utils/ErrorUtils");
-
 var _DocblockUtils = require("./utils/DocblockUtils");
-
 var _TSNodeUtils = require("./utils/TSNodeUtils");
-
 var _os = require("os");
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
-
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
 const DUMMY_LOC = {
   start: {
     line: 1,
@@ -33,33 +22,57 @@ const DUMMY_LOC = {
     column: 0
   }
 };
-
 function constructFlowNode(node) {
   return node;
 }
-
-const cloneJSDocCommentsToNewNode = _hermesTransform.cloneJSDocCommentsToNewNode;
-const makeCommentOwnLine = _hermesTransform.makeCommentOwnLine;
+const cloneJSDocCommentsToNewNode = _flowTransform.cloneJSDocCommentsToNewNode;
+const makeCommentOwnLine = _flowTransform.makeCommentOwnLine;
+function normalizeDeclareComponentParams(params, rest, onUnexpected) {
+  const normalizedParams = [];
+  let normalizedRest = rest;
+  const toComponentTypeParameter = (name, local, source) => {
+    if (local.type !== 'Identifier' || local.typeAnnotation == null) {
+      throw onUnexpected(source, `DeclareComponent: expected an annotated identifier parameter, got "${local.type}"`);
+    }
+    return constructFlowNode({
+      type: 'ComponentTypeParameter',
+      name,
+      typeAnnotation: local.typeAnnotation.typeAnnotation,
+      optional: local.optional,
+      loc: source.loc,
+      range: source.range
+    });
+  };
+  for (const param of params) {
+    switch (param.type) {
+      case 'ComponentTypeParameter':
+        normalizedParams.push(param);
+        break;
+      case 'ComponentParameter':
+        normalizedParams.push(toComponentTypeParameter(param.name, param.local, param));
+        break;
+      case 'RestElement':
+        normalizedRest = toComponentTypeParameter(null, param.argument, param);
+        break;
+    }
+  }
+  return [normalizedParams, normalizedRest];
+}
 const VALID_REACT_IMPORTS = new Set(['React', 'react']);
-
 function isValidReactImportOrGlobal(id) {
   return VALID_REACT_IMPORTS.has(id.name) || id.name.startsWith('React$');
 }
-
 let shouldAddReactImport = null;
-
 function getReactIdentifier(hasReactImport) {
   if (shouldAddReactImport !== false) {
     shouldAddReactImport = !hasReactImport;
   }
-
   return {
     type: 'Identifier',
     loc: DUMMY_LOC,
     name: `React`
   };
 }
-
 function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
   const tsBody = [];
   const tsProgram = {
@@ -71,7 +84,6 @@ function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
   };
   shouldAddReactImport = null;
   const [transform, code] = getTransforms(originalCode, scopeManager, opts);
-
   for (const node of ast.body) {
     if (node.type in transform) {
       const result = transform[node.type](node);
@@ -82,7 +94,6 @@ function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
       });
     }
   }
-
   if (shouldAddReactImport === true) {
     tsBody.unshift({
       type: 'ImportDeclaration',
@@ -106,36 +117,28 @@ function flowDefToTSDef(originalCode, ast, scopeManager, opts) {
       importKind: 'value'
     });
   }
-
   return [tsProgram, code];
 }
-
 const getTransforms = (originalCode, scopeManager, opts) => {
   let code = originalCode;
-
   function translationError(node, message) {
     return (0, _ErrorUtils.translationError)(node, message, {
       code
     });
   }
-
   function unexpectedTranslationError(node, message) {
     return (0, _ErrorUtils.unexpectedTranslationError)(node, message, {
       code
     });
   }
-
   function unsupportedFeatureMessage(thing) {
     return `Unsupported feature: Translating "${thing}" is currently not supported.`;
   }
-
   function buildCodeFrameForComment(node, message) {
     return (0, _ErrorUtils.buildCodeFrame)(node, message, code, false);
   }
-
   function addErrorComment(node, message) {
     var _node$comments;
-
     const comment = {
       type: 'Block',
       loc: DUMMY_LOC,
@@ -147,10 +150,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
     (_node$comments = node.comments) != null ? _node$comments : node.comments = [];
     node.comments.push(comment);
   }
-
   function unsupportedAnnotation(node, thing) {
     const message = unsupportedFeatureMessage(thing);
-
     if (opts.recoverFromErrors) {
       const codeFrame = buildCodeFrameForComment(node, message);
       const newNode = {
@@ -160,13 +161,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       addErrorComment(newNode, codeFrame);
       return newNode;
     }
-
     throw translationError(node, message);
   }
-
   function unsupportedDeclaration(node, thing, id, declare = false, typeParameters = null) {
     const message = unsupportedFeatureMessage(thing);
-
     if (opts.recoverFromErrors) {
       const codeFrame = buildCodeFrameForComment(node, message);
       const newNode = {
@@ -183,37 +181,28 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       addErrorComment(newNode, codeFrame);
       return newNode;
     }
-
     throw translationError(node, message);
   }
-
   const topScope = (() => {
     const globalScope = scopeManager.globalScope;
-
     if (globalScope.childScopes.length > 0 && globalScope.childScopes[0].type === 'module') {
       return globalScope.childScopes[0];
     }
-
     return globalScope;
   })();
-
   function isReactImport(scopeNode, name) {
     let currentScope = (() => {
       let scope = null;
       let node = scopeNode;
-
       while (!scope && node) {
         scope = scopeManager.acquire(node, true);
         node = node.parent;
       }
-
       return scope;
     })();
-
     if (currentScope == null) {
       throw new Error('unable to resolve scope');
     }
-
     const variableDef = (() => {
       while (currentScope != null) {
         for (const variable of currentScope.variables) {
@@ -221,49 +210,37 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             return variable;
           }
         }
-
         currentScope = currentScope.upper;
       }
     })();
-
     if (variableDef == null) {
       return false;
     }
-
     const def = variableDef.defs[0];
-
     switch (def.type) {
       case 'ImportBinding':
         {
           if (def.node.type === 'ImportDefaultSpecifier' || def.node.type === 'ImportNamespaceSpecifier') {
             return VALID_REACT_IMPORTS.has(def.parent.source.value);
           }
-
           return false;
         }
-
       case 'ImplicitGlobalVariable':
         {
           return VALID_REACT_IMPORTS.has(name);
         }
     }
-
     return false;
   }
-
   function EnumImpl(node) {
     const body = node.body;
-
     if (body.type === 'EnumSymbolBody') {
       return unsupportedDeclaration(node, 'symbol enums', node.id, FlowESTree.isDeclareEnum(node));
     }
-
     if (body.type === 'EnumBooleanBody') {
       return unsupportedDeclaration(node, 'boolean enums', node.id, FlowESTree.isDeclareEnum(node));
     }
-
     const members = [];
-
     for (const member of body.members) {
       switch (member.type) {
         case 'EnumDefaultedMember':
@@ -271,7 +248,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             if (body.type === 'EnumNumberBody') {
               throw unexpectedTranslationError(member, 'Unexpected defaulted number enum member');
             }
-
             members.push({
               type: 'TSEnumMember',
               loc: DUMMY_LOC,
@@ -286,7 +262,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             });
             break;
           }
-
         case 'EnumNumberMember':
         case 'EnumStringMember':
           members.push({
@@ -298,7 +273,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           });
       }
     }
-
     const bodyRepresentationType = body.type === 'EnumNumberBody' ? {
       type: 'TSNumberKeyword',
       loc: DUMMY_LOC
@@ -525,133 +499,92 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       }
     }];
   }
-
   const getPlaceholderNameForTypeofImport = (() => {
     let typeof_import_count = 0;
     return () => `$$IMPORT_TYPEOF_${++typeof_import_count}$$`;
   })();
-
   const transformTypeAnnotationType = node => {
     switch (node.type) {
       case 'AnyTypeAnnotation':
         return transform.AnyTypeAnnotation(node);
-
       case 'ArrayTypeAnnotation':
         return transform.ArrayTypeAnnotation(node);
-
       case 'BigIntLiteralTypeAnnotation':
         return transform.BigIntLiteralTypeAnnotation(node);
-
       case 'BigIntTypeAnnotation':
         return transform.BigIntTypeAnnotation(node);
-
       case 'BooleanLiteralTypeAnnotation':
         return transform.BooleanLiteralTypeAnnotation(node);
-
       case 'BooleanTypeAnnotation':
         return transform.BooleanTypeAnnotation(node);
-
       case 'EmptyTypeAnnotation':
         return transform.EmptyTypeAnnotation(node);
-
       case 'ExistsTypeAnnotation':
         return transform.ExistsTypeAnnotation(node);
-
       case 'FunctionTypeAnnotation':
         return transform.FunctionTypeAnnotation(node);
-
       case 'GenericTypeAnnotation':
         return transform.GenericTypeAnnotation(node);
-
       case 'IndexedAccessType':
         return transform.IndexedAccessType(node);
-
       case 'InterfaceTypeAnnotation':
         return transform.InterfaceTypeAnnotation(node);
-
       case 'IntersectionTypeAnnotation':
         return transform.IntersectionTypeAnnotation(node);
-
       case 'MixedTypeAnnotation':
         return transform.MixedTypeAnnotation(node);
-
       case 'NullLiteralTypeAnnotation':
         return transform.NullLiteralTypeAnnotation(node);
-
       case 'NullableTypeAnnotation':
         return transform.NullableTypeAnnotation(node);
-
       case 'NumberLiteralTypeAnnotation':
         return transform.NumberLiteralTypeAnnotation(node);
-
       case 'NumberTypeAnnotation':
         return transform.NumberTypeAnnotation(node);
-
       case 'ObjectTypeAnnotation':
         return transform.ObjectTypeAnnotation(node);
-
       case 'OptionalIndexedAccessType':
         return transform.OptionalIndexedAccessType(node);
-
       case 'QualifiedTypeIdentifier':
         return transform.QualifiedTypeIdentifier(node);
-
       case 'StringLiteralTypeAnnotation':
         return transform.StringLiteralTypeAnnotation(node);
-
       case 'StringTypeAnnotation':
         return transform.StringTypeAnnotation(node);
-
       case 'SymbolTypeAnnotation':
         return transform.SymbolTypeAnnotation(node);
-
       case 'ThisTypeAnnotation':
         return transform.ThisTypeAnnotation(node);
-
       case 'TupleTypeAnnotation':
         return transform.TupleTypeAnnotation(node);
-
       case 'TypeofTypeAnnotation':
         return transform.TypeofTypeAnnotation(node);
-
       case 'UnionTypeAnnotation':
         return transform.UnionTypeAnnotation(node);
-
       case 'VoidTypeAnnotation':
         return transform.VoidTypeAnnotation(node);
-
       case 'TypePredicate':
         return transform.TypePredicateAnnotation(node);
-
       case 'ConditionalTypeAnnotation':
         return transform.ConditionalTypeAnnotation(node);
-
       case 'InferTypeAnnotation':
         return transform.InferTypeAnnotation(node);
-
       case 'KeyofTypeAnnotation':
         return transform.KeyofTypeAnnotation(node);
-
       case 'TypeOperator':
         return transform.TypeOperator(node);
-
       case 'ComponentTypeAnnotation':
         return transform.ComponentTypeAnnotation(node);
-
       case 'NeverTypeAnnotation':
         return transform.NeverTypeAnnotation(node);
-
       case 'UndefinedTypeAnnotation':
         return transform.UndefinedTypeAnnotation(node);
-
       case 'UnknownTypeAnnotation':
         return transform.UnknownTypeAnnotation(node);
-
       default:
         throw unexpectedTranslationError(node, `Unhandled type ${node.type}`);
     }
   };
-
   const wellKnownSymbols = new Set(['iterator', 'asyncIterator', 'dispose', 'asyncDispose']);
   const transform = {
     AnyTypeAnnotation(_node) {
@@ -660,7 +593,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         loc: DUMMY_LOC
       };
     },
-
     ArrayTypeAnnotation(node) {
       return {
         type: 'TSArrayType',
@@ -668,7 +600,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         elementType: transformTypeAnnotationType(node.elementType)
       };
     },
-
     BigIntLiteral(node) {
       return {
         type: 'Literal',
@@ -678,10 +609,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     BigIntLiteralTypeAnnotation(node) {
       var _node$bigint;
-
       const bigint = (_node$bigint = node.bigint) != null ? _node$bigint : node.raw.replace(/n$/, '').replace(/_/, '');
       return {
         type: 'TSLiteralType',
@@ -695,14 +624,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     BigIntTypeAnnotation(_node) {
       return {
         type: 'TSBigIntKeyword',
         loc: DUMMY_LOC
       };
     },
-
     BooleanLiteral(node) {
       return {
         type: 'Literal',
@@ -711,7 +638,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     BooleanLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
@@ -724,14 +650,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     BooleanTypeAnnotation(_node) {
       return {
         type: 'TSBooleanKeyword',
         loc: DUMMY_LOC
       };
     },
-
     ClassImplements(node) {
       return {
         type: 'TSClassImplements',
@@ -740,15 +664,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeArguments: transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
-
     DeclareClass(node) {
       const classMembers = [];
       const transformedBody = transform.ObjectTypeAnnotation(node.body);
-
       if (transformedBody.type !== 'TSTypeLiteral') {
         return unsupportedDeclaration(node.body, 'Spreads in declare class are not allowed', node.id, true, node.typeParameters);
       }
-
       for (const member of transformedBody.members) {
         switch (member.type) {
           case 'TSIndexSignature':
@@ -756,17 +677,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               classMembers.push(member);
               break;
             }
-
           case 'TSMethodSignature':
             {
               const isConstructor = (() => {
                 if (member.computed === true) {
                   return false;
                 }
-
                 return member.key.type === 'Identifier' && member.key.name === 'constructor' || member.key.type === 'Literal' && member.key.value === 'constructor';
               })();
-
               if (isConstructor) {
                 const newNode = {
                   type: 'MethodDefinition',
@@ -800,13 +718,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 classMembers.push(newNode);
               } else {
                 var _member$static;
-
                 const [key, computed] = (() => {
                   const _key = member.key;
-
                   if (_key.type === 'Identifier' && _key.name.startsWith('@@')) {
                     const name = _key.name.slice(2);
-
                     if (wellKnownSymbols.has(name)) {
                       return [{
                         type: 'MemberExpression',
@@ -828,10 +743,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                       }, true];
                     }
                   }
-
                   return [member.key, member.computed];
                 })();
-
                 const newNode = {
                   type: 'MethodDefinition',
                   loc: DUMMY_LOC,
@@ -859,14 +772,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 cloneJSDocCommentsToNewNode(member, newNode);
                 classMembers.push(newNode);
               }
-
               break;
             }
-
           case 'TSPropertySignature':
             {
               var _member$computed, _member$static2;
-
               const newNode = {
                 type: 'PropertyDefinition',
                 loc: DUMMY_LOC,
@@ -884,19 +794,15 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               classMembers.push(newNode);
               break;
             }
-
           case 'TSCallSignatureDeclaration':
             {
               var _node$body$callProper;
-
               return unsupportedDeclaration((_node$body$callProper = node.body.callProperties[0]) != null ? _node$body$callProper : node.body, 'call signatures on classes', node.id, true, node.typeParameters);
             }
-
           default:
             throw unexpectedTranslationError(node.body, `Unexpected member type ${member.type}`);
         }
       }
-
       const superClass = node.extends.length > 0 ? node.extends[0] : undefined;
       return {
         type: 'ClassDeclaration',
@@ -914,11 +820,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     DeclareExportDeclaration(node) {
       if (node.default === true) {
         const declaration = node.declaration;
-
         switch (declaration.type) {
           case 'DeclareClass':
             {
@@ -935,7 +839,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-
           case 'DeclareFunction':
             {
               const functionDecl = transform.DeclareFunction(declaration);
@@ -951,7 +854,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-
           case 'DeclareComponent':
             {
               const functionDecl = transform.DeclareComponent(declaration);
@@ -967,7 +869,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-
           case 'DeclareHook':
             {
               const functionDecl = transform.DeclareHook(declaration);
@@ -983,27 +884,21 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 exportKind: 'value'
               }];
             }
-
           case 'GenericTypeAnnotation':
             {
               const referencedId = declaration.id;
-
               if (referencedId.type === 'Identifier') {
                 const exportedVar = topScope.set.get(referencedId.name);
-
                 if (exportedVar != null && exportedVar.defs.length === 1) {
                   const def = exportedVar.defs[0];
-
                   switch (def.type) {
                     case 'ImportBinding':
                       {
                         const specifier = def.node;
-
                         if (specifier.importKind === 'type' || specifier.parent.importKind === 'type') {
                           break;
                         }
                       }
-
                     case 'ClassName':
                     case 'Enum':
                     case 'FunctionName':
@@ -1019,28 +914,23 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                         },
                         exportKind: 'value'
                       };
-
                     case 'CatchClause':
                     case 'Parameter':
                     case 'TypeParameter':
                       throw translationError(def.node, `Unexpected variable def type: ${def.type}`);
-
                     case 'Type':
                       break;
                   }
                 }
               }
             }
-
           case 'TypeofTypeAnnotation':
             {
               if (declaration.type === 'TypeofTypeAnnotation' && declaration.argument.type === 'Identifier') {
                 const name = declaration.argument.name;
                 const exportedVar = topScope.set.get(name);
-
                 if (exportedVar != null && exportedVar.defs.length === 1) {
                   const def = exportedVar.defs[0];
-
                   switch (def.type) {
                     case 'ClassName':
                       {
@@ -1061,7 +951,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             }
-
           default:
             {
               const SPECIFIER = '$$EXPORT_DEFAULT_DECLARATION$$';
@@ -1132,7 +1021,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               specifiers: node.specifiers.map(transform.ExportSpecifier)
             };
           }
-
           const declarations = (() => {
             switch (node.declaration.type) {
               case 'DeclareClass':
@@ -1140,43 +1028,36 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   declaration: transform.DeclareClass(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareComponent':
                 return [{
                   declaration: transform.DeclareComponent(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareHook':
                 return [{
                   declaration: transform.DeclareHook(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareFunction':
                 return [{
                   declaration: transform.DeclareFunction(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareInterface':
                 return [{
                   declaration: transform.DeclareInterface(node.declaration),
                   exportKind: 'type'
                 }];
-
               case 'DeclareOpaqueType':
                 return [{
                   declaration: transform.DeclareOpaqueType(node.declaration),
                   exportKind: 'type'
                 }];
-
               case 'DeclareVariable':
                 return [{
                   declaration: transform.DeclareVariable(node.declaration),
                   exportKind: 'value'
                 }];
-
               case 'DeclareEnum':
                 {
                   const result = transform.DeclareEnum(node.declaration);
@@ -1193,14 +1074,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
             }
           })();
-
           const mappedDeclarations = declarations.map(({
             declaration,
             exportKind
           }) => {
             if (declaration.type === 'VariableDeclaration' && declaration.declarations.length === 1) {
               const ident = declaration.declarations[0].id;
-
               if (ident.type === 'Identifier') {
                 const name = ident.name;
                 return [{
@@ -1244,7 +1123,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }];
               }
             }
-
             const exportNamedDeclaration = {
               type: 'ExportNamedDeclaration',
               loc: DUMMY_LOC,
@@ -1270,11 +1148,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       }
     },
-
     DeclareComponent(node) {
       const id = transform.Identifier(node.id, false);
       const typeParameters = node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters);
-      const params = transform.ComponentTypeParameters(node.params, node.rest);
+      const [declaredParams, declaredRest] = normalizeDeclareComponentParams(node.params, node.rest, unexpectedTranslationError);
+      const params = transform.ComponentTypeParameters(declaredParams, declaredRest);
       const hasReactImport = isReactImport(node, 'React');
       const returnType = {
         type: 'TSTypeAnnotation',
@@ -1313,7 +1191,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: typeParameters
       };
     },
-
     ComponentTypeParameters(params, rest) {
       if (params.length === 0 && rest != null) {
         return [{
@@ -1328,9 +1205,7 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           optional: false
         }];
       }
-
       const flowPropsType = [];
-
       if (rest != null) {
         flowPropsType.push(constructFlowNode({
           type: 'ObjectTypeSpreadProperty',
@@ -1339,10 +1214,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           loc: rest.loc
         }));
       }
-
       for (let i = 0; i < params.length; i++) {
         var _param$name;
-
         const param = params[i];
         flowPropsType.push(constructFlowNode({
           type: 'ObjectTypeProperty',
@@ -1363,7 +1236,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           loc: param.loc
         }));
       }
-
       const tsPropsObjectType = transform.ObjectTypeAnnotation(constructFlowNode({
         type: 'ObjectTypeAnnotation',
         inexact: false,
@@ -1385,7 +1257,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         optional: false
       }];
     },
-
     DeclareHook(node) {
       const id = transform.Identifier(node.id, false);
       const functionInfo = transform.FunctionTypeAnnotation(node.id.typeAnnotation.typeAnnotation);
@@ -1407,7 +1278,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: functionInfo.typeParameters
       };
     },
-
     DeclareFunction(node) {
       const id = transform.Identifier(node.id, false);
       const functionInfo = transform.FunctionTypeAnnotation(node.id.typeAnnotation.typeAnnotation);
@@ -1429,14 +1299,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: functionInfo.typeParameters
       };
     },
-
     DeclareInterface(node) {
       const transformedBody = transform.ObjectTypeAnnotation(node.body);
-
       if (transformedBody.type !== 'TSTypeLiteral') {
         throw translationError(node.body, 'Spreads in interfaces are not allowed');
       }
-
       return {
         type: 'TSInterfaceDeclaration',
         loc: DUMMY_LOC,
@@ -1451,7 +1318,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     DeclareTypeAlias(node) {
       return {
         type: 'TSTypeAliasDeclaration',
@@ -1462,7 +1328,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     DeclareOpaqueType(node) {
       if (node.supertype == null && node.typeParameters == null) {
         const name = `__${node.id.name}__`;
@@ -1502,7 +1367,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
         };
       }
-
       return {
         type: 'TSTypeAliasDeclaration',
         loc: DUMMY_LOC,
@@ -1515,43 +1379,41 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     DeclareVariable(node) {
       return {
         type: 'VariableDeclaration',
         loc: DUMMY_LOC,
         declare: true,
-        declarations: [{
-          type: 'VariableDeclarator',
-          loc: DUMMY_LOC,
-          declare: true,
-          id: transform.Identifier(node.id, true),
-          init: null
-        }],
+        declarations: node.declarations.map(declaration => {
+          if (declaration.id.type !== 'Identifier') {
+            throw translationError(declaration.id, `DeclareVariable: unsupported declarator of type "${declaration.id.type}"`);
+          }
+          return {
+            type: 'VariableDeclarator',
+            loc: DUMMY_LOC,
+            declare: true,
+            id: transform.Identifier(declaration.id, true),
+            init: null
+          };
+        }),
         kind: node.kind
       };
     },
-
     DeclareEnum(node) {
       return EnumImpl(node);
     },
-
     EmptyTypeAnnotation(node) {
       return unsupportedAnnotation(node, 'empty type');
     },
-
     EnumDeclaration(node) {
       return EnumImpl(node);
     },
-
     DeclareModuleExports(node) {
       throw translationError(node, 'CommonJS exports are not supported.');
     },
-
     ExistsTypeAnnotation(node) {
       return unsupportedAnnotation(node, 'existential type');
     },
-
     ExportAllDeclaration(node) {
       return {
         type: 'ExportAllDeclaration',
@@ -1562,7 +1424,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         exported: node.exported == null ? null : transform.Identifier(node.exported)
       };
     },
-
     ExportNamedDeclaration(node) {
       if (node.source != null || node.specifiers.length > 0) {
         return {
@@ -1575,12 +1436,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           specifiers: node.specifiers.map(transform.ExportSpecifier)
         };
       }
-
       const [exportedDeclaration, mergedDeclaration] = (() => {
         if (node.declaration == null) {
           return [null, null];
         }
-
         switch (node.declaration.type) {
           case 'ClassDeclaration':
           case 'ComponentDeclaration':
@@ -1589,24 +1448,19 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           case 'FunctionDeclaration':
           case 'VariableDeclaration':
             throw unexpectedTranslationError(node.declaration, `Unexpected named declaration found ${node.declaration.type}`);
-
           case 'EnumDeclaration':
             {
               const result = transform.EnumDeclaration(node.declaration);
               return Array.isArray(result) ? result : [result, null];
             }
-
           case 'InterfaceDeclaration':
             return [transform.InterfaceDeclaration(node.declaration), null];
-
           case 'OpaqueType':
             return [transform.OpaqueType(node.declaration), null];
-
           case 'TypeAlias':
             return [transform.TypeAlias(node.declaration), null];
         }
       })();
-
       const mainExport = {
         type: 'ExportNamedDeclaration',
         loc: DUMMY_LOC,
@@ -1616,7 +1470,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         source: null,
         specifiers: []
       };
-
       if (mergedDeclaration != null) {
         return [mainExport, {
           type: 'ExportNamedDeclaration',
@@ -1628,10 +1481,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           specifiers: []
         }];
       }
-
       return mainExport;
     },
-
     ExportSpecifier(node) {
       return {
         type: 'ExportSpecifier',
@@ -1641,10 +1492,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         exportKind: 'value'
       };
     },
-
     FunctionTypeAnnotation(node) {
       const params = node.params.map(transform.FunctionTypeParam);
-
       if (node.type === 'FunctionTypeAnnotation' && node.this != null) {
         params.unshift({
           type: 'Identifier',
@@ -1657,7 +1506,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
         });
       }
-
       if (node.rest != null) {
         const rest = node.rest;
         params.push({
@@ -1675,7 +1523,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
         });
       }
-
       return {
         type: 'TSFunctionType',
         loc: DUMMY_LOC,
@@ -1688,7 +1535,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters)
       };
     },
-
     FunctionTypeParam(node, idx = 0) {
       return {
         type: 'Identifier',
@@ -1702,12 +1548,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         optional: node.optional
       };
     },
-
     GenericTypeAnnotation(node) {
       const [fullTypeName, baseId] = (() => {
         let names = [];
         let currentNode = node.id;
-
         while (currentNode != null) {
           switch (currentNode.type) {
             case 'Identifier':
@@ -1715,7 +1559,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 names.unshift(currentNode.name);
                 return [names.join('.'), currentNode];
               }
-
             case 'QualifiedTypeIdentifier':
               {
                 names.unshift(currentNode.id.name);
@@ -1724,54 +1567,40 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
           }
         }
-
         throw translationError(node, `Invalid program state, types should only contain 'Identifier' and 'QualifiedTypeIdentifier' nodes.`);
       })();
-
       const assertHasExactlyNTypeParameters = count => {
         if (node.typeParameters != null) {
           if (node.typeParameters.params.length !== count) {
             throw translationError(node, `Expected exactly ${count} type parameter${count > 1 ? 's' : ''} with \`${fullTypeName}\``);
           }
-
           const res = [];
-
           for (const param of node.typeParameters.params) {
             res.push(transformTypeAnnotationType(param));
           }
-
           return res;
         }
-
         if (count !== 0) {
           throw translationError(node, `Expected no type parameters with \`${fullTypeName}\``);
         }
-
         return [];
       };
-
       function assertHasTypeParametersInRange(min, max) {
         const {
           typeParameters
         } = node;
-
         if (typeParameters == null) {
           if (min > 0) {
             throw translationError(node, `Expected between ${min} and ${max} type parameters with \`${fullTypeName}\`, but got none.`);
           }
-
           return [];
         }
-
         const params = typeParameters.params;
-
         if (params.length < min || params.length > max) {
           throw translationError(node, `Expected between ${min} and ${max} type parameters with \`${fullTypeName}\`, but got ${params.length}.`);
         }
-
         return typeParameters.params.map(transformTypeAnnotationType);
       }
-
       switch (fullTypeName) {
         case '$Call':
         case '$ObjMap':
@@ -1781,7 +1610,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           {
             return unsupportedAnnotation(node, fullTypeName);
           }
-
         case '$ArrayBufferView':
           {
             return {
@@ -1794,7 +1622,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$ArrayLike':
           {
             return {
@@ -1812,7 +1639,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$Diff':
         case '$Rest':
           {
@@ -1855,7 +1681,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$ElementType':
         case '$PropertyType':
           {
@@ -1867,20 +1692,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               indexType: params[1]
             };
           }
-
         case '$Exact':
           {
             return assertHasExactlyNTypeParameters(1)[0];
           }
-
         case '$Exports':
           {
             const moduleName = assertHasExactlyNTypeParameters(1)[0];
-
             if (moduleName.type !== 'TSLiteralType' || moduleName.literal.type !== 'Literal' || typeof moduleName.literal.value !== 'string') {
               throw translationError(node, '$Exports must have a string literal argument');
             }
-
             return {
               type: 'TSTypeQuery',
               loc: DUMMY_LOC,
@@ -1895,7 +1716,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$FlowFixMe':
           {
             return {
@@ -1903,7 +1723,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               loc: DUMMY_LOC
             };
           }
-
         case '$KeyMirror':
           {
             return {
@@ -1949,7 +1768,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$Keys':
           {
             return {
@@ -1959,7 +1777,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               typeAnnotation: assertHasExactlyNTypeParameters(1)[0]
             };
           }
-
         case '$NonMaybeType':
           {
             return {
@@ -1977,7 +1794,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$ReadOnly':
           {
             return {
@@ -1995,7 +1811,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$ReadOnlyArray':
           {
             return {
@@ -2013,7 +1828,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$ReadOnlyMap':
           {
             return {
@@ -2031,7 +1845,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$ReadOnlySet':
           {
             return {
@@ -2049,7 +1862,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case '$Values':
         case 'Values':
           {
@@ -2066,15 +1878,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case 'Class':
           {
             const param = assertHasExactlyNTypeParameters(1)[0];
-
             if (param.type !== 'TSTypeReference') {
               throw translationError(node, 'Expected a type reference within Class<T>');
             }
-
             return {
               type: 'TSConstructorType',
               loc: DUMMY_LOC,
@@ -2107,18 +1916,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               }
             };
           }
-
         case 'StringPrefix':
           {
             var _params$;
-
             const params = assertHasTypeParametersInRange(1, 2);
             const prefix = params[0];
-
             if (prefix.type !== 'TSLiteralType' || typeof prefix.literal.value !== 'string') {
               throw translationError(node, 'Expected a string literal for the first type parameter.');
             }
-
             const prefixStr = prefix.literal.value;
             const remainder = (_params$ = params[1]) != null ? _params$ : {
               type: 'TSStringKeyword',
@@ -2147,18 +1952,14 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               types: [remainder]
             };
           }
-
         case 'StringSuffix':
           {
             var _params$2;
-
             const params = assertHasTypeParametersInRange(1, 2);
             const suffix = params[0];
-
             if (suffix.type !== 'TSLiteralType' || typeof suffix.literal.value !== 'string') {
               throw translationError(node, 'Expected a string literal for the first type parameter.');
             }
-
             const suffixStr = suffix.literal.value;
             const remainder = (_params$2 = params[1]) != null ? _params$2 : {
               type: 'TSStringKeyword',
@@ -2188,10 +1989,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             };
           }
       }
-
       const validReactImportOrGlobal = isValidReactImportOrGlobal(baseId);
       const hasReactImport = isReactImport(baseId, baseId.name);
-
       if (validReactImportOrGlobal || hasReactImport) {
         switch (fullTypeName) {
           case 'React.ChildrenArray':
@@ -2217,22 +2016,17 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }]
               };
             }
-
           case 'React.Component':
           case 'React$Component':
             {
               const typeParameters = node.typeParameters;
-
               if (typeParameters == null || typeParameters.params.length === 0) {
                 throw translationError(node, `Expected at least 1 type parameter with \`${fullTypeName}\``);
               }
-
               const params = typeParameters.params;
-
               if (params.length > 2) {
                 throw translationError(node, `Expected at no more than 2 type parameters with \`${fullTypeName}\``);
               }
-
               return {
                 type: 'TSTypeReference',
                 loc: DUMMY_LOC,
@@ -2253,7 +2047,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-
           case 'React$Context':
           case 'React.Context':
             return {
@@ -2275,7 +2068,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
-
           case 'React.Key':
           case 'React$Key':
             assertHasExactlyNTypeParameters(0);
@@ -2293,7 +2085,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             };
-
           case 'React$ElementType':
           case 'React.ElementType':
             {
@@ -2314,7 +2105,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 typeArguments: undefined
               };
             }
-
           case 'React$Node':
           case 'React.Node':
             {
@@ -2335,7 +2125,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 typeArguments: undefined
               };
             }
-
           case 'React$Element':
           case 'React.Element':
             {
@@ -2359,7 +2148,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-
           case 'React$ElementRef':
           case 'React.ElementRef':
             return {
@@ -2381,7 +2169,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
-
           case 'React$FragmentType':
           case 'React.Fragment':
             assertHasExactlyNTypeParameters(0);
@@ -2399,7 +2186,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               }
             };
-
           case 'React$MixedElement':
           case 'React.MixedElement':
             {
@@ -2433,7 +2219,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 typeArguments: undefined
               };
             }
-
           case 'React.ComponentType':
           case 'React$ComponentType':
             {
@@ -2457,27 +2242,21 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-
           case 'React.AbstractComponent':
           case 'React$AbstractComponent':
             {
               const typeParameters = node.typeParameters;
-
               if (typeParameters == null || typeParameters.params.length === 0) {
                 throw translationError(node, `Expected at least 1 type parameter with \`${fullTypeName}\``);
               }
-
               const params = typeParameters.params;
-
               if (params.length > 3) {
                 throw translationError(node, `Expected at no more than 3 type parameters with \`${fullTypeName}\``);
               }
-
               const newParams = (() => {
                 if (params.length === 1) {
                   return assertHasExactlyNTypeParameters(1);
                 }
-
                 const props = transformTypeAnnotationType(params[0]);
                 const ref = transformTypeAnnotationType(params[1]);
                 return [{
@@ -2508,7 +2287,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                   }]
                 }];
               })();
-
               return {
                 type: 'TSTypeReference',
                 loc: DUMMY_LOC,
@@ -2529,7 +2307,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-
           case 'React.ElementProps':
           case 'React$ElementProps':
             {
@@ -2553,7 +2330,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-
           case 'React.ElementConfig':
           case 'React$ElementConfig':
             {
@@ -2609,7 +2385,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 }
               };
             }
-
           case 'React.RefSetter':
           case 'React$RefSetter':
             return {
@@ -2631,12 +2406,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 params: assertHasExactlyNTypeParameters(1)
               }
             };
-
           default:
             return unsupportedAnnotation(node, fullTypeName);
         }
       }
-
       return {
         type: 'TSTypeReference',
         loc: DUMMY_LOC,
@@ -2644,7 +2417,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeArguments: transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
-
     Identifier(node, includeTypeAnnotation = true) {
       return {
         type: 'Identifier',
@@ -2655,7 +2427,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         } : {})
       };
     },
-
     IndexedAccessType(node) {
       return {
         type: 'TSIndexedAccessType',
@@ -2664,11 +2435,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         indexType: transformTypeAnnotationType(node.indexType)
       };
     },
-
     InterfaceDeclaration(node) {
       return transform.DeclareInterface(node);
     },
-
     ImportAttribute(node) {
       return {
         type: 'ImportAttribute',
@@ -2677,7 +2446,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: transform.Literal(node.value)
       };
     },
-
     ImportDeclaration(node) {
       const importKind = node.importKind;
       const specifiers = [];
@@ -2702,10 +2470,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             });
             return id;
           }
-
           return transform.Identifier(spec.local, false);
         })();
-
         switch (spec.type) {
           case 'ImportDefaultSpecifier':
             specifiers.push({
@@ -2714,7 +2480,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               local: id
             });
             return;
-
           case 'ImportNamespaceSpecifier':
             specifiers.push({
               type: 'ImportNamespaceSpecifier',
@@ -2722,7 +2487,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               local: id
             });
             return;
-
           case 'ImportSpecifier':
             specifiers.push({
               type: 'ImportSpecifier',
@@ -2744,7 +2508,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
       }] : [];
       return [...out, ...unsupportedSpecifiers];
     },
-
     InterfaceExtends(node) {
       return {
         type: 'TSInterfaceHeritage',
@@ -2753,7 +2516,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeArguments: transform.TypeParameterInstantiation(node.typeParameters)
       };
     },
-
     InterfaceTypeAnnotation(node) {
       if (node.extends) {
         return {
@@ -2767,10 +2529,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           })), transform.ObjectTypeAnnotation(node.body)]
         };
       }
-
       return transform.ObjectTypeAnnotation(node.body);
     },
-
     IntersectionTypeAnnotation(node) {
       return {
         type: 'TSIntersectionType',
@@ -2778,36 +2538,28 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         types: node.types.map(transformTypeAnnotationType)
       };
     },
-
     Literal(node) {
       switch (node.literalType) {
         case 'bigint':
           return transform.BigIntLiteral(node);
-
         case 'boolean':
           return transform.BooleanLiteral(node);
-
         case 'null':
           return transform.NullLiteral(node);
-
         case 'numeric':
           return transform.NumericLiteral(node);
-
         case 'regexp':
           return transform.RegExpLiteral(node);
-
         case 'string':
           return transform.StringLiteral(node);
       }
     },
-
     MixedTypeAnnotation(_node) {
       return {
         type: 'TSUnknownKeyword',
         loc: DUMMY_LOC
       };
     },
-
     NullLiteral(_node) {
       return {
         type: 'Literal',
@@ -2816,14 +2568,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: null
       };
     },
-
     NullLiteralTypeAnnotation(_node) {
       return {
         type: 'TSNullKeyword',
         loc: DUMMY_LOC
       };
     },
-
     NullableTypeAnnotation(node) {
       return {
         type: 'TSUnionType',
@@ -2837,7 +2587,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }, transformTypeAnnotationType(node.typeAnnotation)]
       };
     },
-
     NumberLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
@@ -2850,14 +2599,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     NumberTypeAnnotation(_node) {
       return {
         type: 'TSNumberKeyword',
         loc: DUMMY_LOC
       };
     },
-
     NumericLiteral(node) {
       return {
         type: 'Literal',
@@ -2866,11 +2613,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     ObjectTypeAnnotation(node) {
       if (node.properties.length === 1 && node.properties[0].type === 'ObjectTypeMappedTypeProperty') {
         var _prop$variance, _prop$variance2;
-
         const prop = node.properties[0];
         const tsProp = {
           type: 'TSMappedType',
@@ -2900,43 +2645,35 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         };
         return tsProp;
       }
-
       const members = [];
-
       for (const callProp of node.callProperties) {
         members.push({
           start: callProp.range[0],
           node: transform.ObjectTypeCallProperty(callProp)
         });
       }
-
       for (const indexer of node.indexers) {
         members.push({
           start: indexer.range[0],
           node: transform.ObjectTypeIndexer(indexer)
         });
       }
-
       if (node.internalSlots.length > 0) {
         return unsupportedAnnotation(node.internalSlots[0], 'internal slots');
       }
-
       if (!node.properties.find(FlowESTree.isObjectTypeSpreadProperty)) {
         for (const property of node.properties) {
           if (property.type === 'ObjectTypeSpreadProperty') {
             throw unexpectedTranslationError(property, 'Impossible state');
           }
-
           if (property.type === 'ObjectTypeMappedTypeProperty') {
             return unsupportedAnnotation(property, 'object type with mapped type property along with other properties');
           }
-
           members.push({
             start: property.range[0],
             node: transform.ObjectTypeProperty(property)
           });
         }
-
         const tsBody = members.sort((a, b) => a.start - b.start).map(({
           node
         }) => node);
@@ -2947,25 +2684,19 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         };
       } else {
         var _extractPropertyKeyLi;
-
         if (members.length > 0) {
           return unsupportedAnnotation(node, 'object types with spreads, indexers and/or call properties at the same time');
         }
-
         const typesToIntersect = [];
-
         for (const property of node.properties) {
           if (property.type === 'ObjectTypeSpreadProperty') {
             if (members.length > 0) {
               return unsupportedAnnotation(property, 'object types with spreads in the middle or at the end');
             }
-
             const spreadType = transformTypeAnnotationType(property.argument);
-
             if (spreadType.type !== 'TSTypeReference' && spreadType.type !== 'TSTypeQuery') {
               return unsupportedAnnotation(property, 'object types with complex spreads');
             }
-
             typesToIntersect.push(spreadType);
           } else if (property.type === 'ObjectTypeMappedTypeProperty') {
             return unsupportedAnnotation(property, 'object type with mapped type property');
@@ -2976,7 +2707,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             });
           }
         }
-
         const tsBody = members.sort((a, b) => a.start - b.start).map(({
           node
         }) => node);
@@ -2992,7 +2722,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           typeAnnotation: objectType
         }];
         const intersectionMembers = [];
-
         for (let i = 0; i < typesToIntersect.length; i += 1) {
           const currentType = typesToIntersect[i];
           const remainingTypes = typesToIntersect.slice(i + 1);
@@ -3021,7 +2750,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             }
           });
         }
-
         intersectionMembers.push(objectType);
         return {
           type: 'TSIntersectionType',
@@ -3030,7 +2758,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         };
       }
     },
-
     ObjectTypeCallProperty(node) {
       const func = transform.FunctionTypeAnnotation(node.value);
       return {
@@ -3041,13 +2768,10 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameters: func.typeParameters
       };
     },
-
     ObjectTypeIndexer(node) {
       var _node$variance3, _node$variance4;
-
       if (node.key.type === 'GenericTypeAnnotation') {
         var _node$variance, _node$variance2;
-
         const ident = node.key.id.type === 'Identifier' ? node.key.id : node.key.id.id;
         return {
           type: 'TSPropertySignature',
@@ -3077,7 +2801,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
         };
       }
-
       return {
         type: 'TSIndexSignature',
         loc: DUMMY_LOC,
@@ -3100,14 +2823,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     ObjectTypeProperty(node) {
       var _node$variance5, _node$variance6;
-
       const [key, computed] = (() => {
         if (node.key.type === 'Identifier' && node.key.name.startsWith('@@')) {
           const name = node.key.name.slice(2);
-
           if (node.method === true && wellKnownSymbols.has(name)) {
             return [{
               type: 'MemberExpression',
@@ -3129,16 +2849,12 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             }, true];
           }
         }
-
         const key = node.key.type === 'Identifier' ? transform.Identifier(node.key) : node.key.literalType === 'string' ? transform.StringLiteral(node.key) : null;
-
         if (key == null) {
           throw unexpectedTranslationError(node, 'Unsupported key type');
         }
-
         return [key, false];
       })();
-
       if (node.method === true) {
         const func = transform.FunctionTypeAnnotation(node.value);
         return {
@@ -3154,7 +2870,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           typeParameters: func.typeParameters
         };
       }
-
       if (node.kind === 'get' || node.kind === 'set') {
         const func = transform.FunctionTypeAnnotation(node.value);
         return {
@@ -3170,7 +2885,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           typeParameters: undefined
         };
       }
-
       return {
         type: 'TSPropertySignature',
         loc: DUMMY_LOC,
@@ -3182,20 +2896,17 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: {
           type: 'TSTypeAnnotation',
           loc: DUMMY_LOC,
-          typeAnnotation: transformTypeAnnotationType(node.value)
+          typeAnnotation: node.optional === true ? (0, _TSNodeUtils.ensureTypeIncludesUndefined)(transformTypeAnnotationType(node.value)) : transformTypeAnnotationType(node.value)
         }
       };
     },
-
     OpaqueType(node) {
       return transform.DeclareOpaqueType(node);
     },
-
     OptionalIndexedAccessType(node) {
       if (node.optional === false) {
         return transform.IndexedAccessType(node);
       }
-
       return {
         type: 'TSIndexedAccessType',
         loc: DUMMY_LOC,
@@ -3216,7 +2927,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         indexType: transformTypeAnnotationType(node.indexType)
       };
     },
-
     QualifiedTypeIdentifier(node) {
       const qual = node.qualification;
       return {
@@ -3226,7 +2936,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         right: transform.Identifier(node.id, false)
       };
     },
-
     QualifiedTypeofIdentifier(node) {
       const qual = node.qualification;
       return {
@@ -3236,7 +2945,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         right: transform.Identifier(node.id, false)
       };
     },
-
     RegExpLiteral(node) {
       return {
         type: 'Literal',
@@ -3249,7 +2957,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     StringLiteral(node) {
       return {
         type: 'Literal',
@@ -3258,7 +2965,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         value: node.value
       };
     },
-
     StringLiteralTypeAnnotation(node) {
       return {
         type: 'TSLiteralType',
@@ -3271,28 +2977,24 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     StringTypeAnnotation(_node) {
       return {
         type: 'TSStringKeyword',
         loc: DUMMY_LOC
       };
     },
-
     SymbolTypeAnnotation(_node) {
       return {
         type: 'TSSymbolKeyword',
         loc: DUMMY_LOC
       };
     },
-
     ThisTypeAnnotation(_node) {
       return {
         type: 'TSThisType',
         loc: DUMMY_LOC
       };
     },
-
     TupleTypeAnnotation(node) {
       const allReadOnly = node.elementTypes.length > 0 && node.elementTypes.every(element => element.type === 'TupleTypeLabeledElement' && element.variance != null && (element.variance.kind === 'plus' || element.variance.kind === 'readonly'));
       const elems = node.elementTypes.map(element => {
@@ -3301,7 +3003,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             if (!allReadOnly && element.variance != null) {
               return unsupportedAnnotation(element, 'tuple type element variance annotations');
             }
-
             return {
               type: 'TSNamedTupleMember',
               loc: DUMMY_LOC,
@@ -3309,7 +3010,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
               optional: element.optional,
               elementType: transformTypeAnnotationType(element.elementType)
             };
-
           case 'TupleTypeSpreadElement':
             {
               const annot = transformTypeAnnotationType(element.typeAnnotation);
@@ -3325,7 +3025,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
                 } : annot
               };
             }
-
           default:
             return transformTypeAnnotationType(element);
         }
@@ -3354,11 +3053,9 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: tupleAnnot
       } : tupleAnnot;
     },
-
     TypeAlias(node) {
       return transform.DeclareTypeAlias(node);
     },
-
     TypeAnnotation(node) {
       return {
         type: 'TSTypeAnnotation',
@@ -3366,7 +3063,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: transformTypeAnnotationType(node.typeAnnotation)
       };
     },
-
     TypeofTypeAnnotation(node) {
       switch (node.argument.type) {
         case 'Identifier':
@@ -3376,7 +3072,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
             exprName: transform.Identifier(node.argument),
             typeArguments: undefined
           };
-
         case 'QualifiedTypeofIdentifier':
           return {
             type: 'TSTypeQuery',
@@ -3386,7 +3081,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           };
       }
     },
-
     TypeParameter(node) {
       return {
         type: 'TSTypeParameter',
@@ -3402,7 +3096,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         out: false
       };
     },
-
     TypeParameterDeclaration(node) {
       return {
         type: 'TSTypeParameterDeclaration',
@@ -3410,19 +3103,16 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         params: node.params.map(transform.TypeParameter)
       };
     },
-
     TypeParameterInstantiation(node) {
       if (node == null || node.params.length === 0) {
         return undefined;
       }
-
       return {
         type: 'TSTypeParameterInstantiation',
         loc: DUMMY_LOC,
         params: node.params.map(transformTypeAnnotationType)
       };
     },
-
     UnionTypeAnnotation(node) {
       return {
         type: 'TSUnionType',
@@ -3430,35 +3120,30 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         types: node.types.map(transformTypeAnnotationType)
       };
     },
-
     VoidTypeAnnotation(_node) {
       return {
         type: 'TSVoidKeyword',
         loc: DUMMY_LOC
       };
     },
-
     NeverTypeAnnotation(_node) {
       return {
         type: 'TSNeverKeyword',
         loc: DUMMY_LOC
       };
     },
-
     UndefinedTypeAnnotation(_node) {
       return {
         type: 'TSUndefinedKeyword',
         loc: DUMMY_LOC
       };
     },
-
     UnknownTypeAnnotation(_node) {
       return {
         type: 'TSUnknownKeyword',
         loc: DUMMY_LOC
       };
     },
-
     ConditionalTypeAnnotation(node) {
       return {
         type: 'TSConditionalType',
@@ -3469,7 +3154,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         falseType: transformTypeAnnotationType(node.falseType)
       };
     },
-
     TypePredicateAnnotation(node) {
       return {
         type: 'TSTypePredicate',
@@ -3483,7 +3167,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         }
       };
     },
-
     InferTypeAnnotation(node) {
       return {
         type: 'TSInferType',
@@ -3491,7 +3174,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeParameter: transform.TypeParameter(node.typeParameter)
       };
     },
-
     KeyofTypeAnnotation(node) {
       return {
         type: 'TSTypeOperator',
@@ -3500,7 +3182,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         typeAnnotation: transformTypeAnnotationType(node.argument)
       };
     },
-
     TypeOperator(node) {
       switch (node.operator) {
         case 'renders':
@@ -3526,7 +3207,6 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           }
       }
     },
-
     ComponentTypeAnnotation(node) {
       const typeParameters = node.typeParameters == null ? undefined : transform.TypeParameterDeclaration(node.typeParameters);
       const params = transform.ComponentTypeParameters(node.params, node.rest);
@@ -3558,15 +3238,11 @@ const getTransforms = (originalCode, scopeManager, opts) => {
         returnType
       };
     }
-
   };
-
   for (const key of Object.keys(transform)) {
     const originalFn = transform[key];
-
     transform[key] = (node, ...args) => {
       const result = originalFn(node, ...args);
-
       if (node != null && result != null) {
         if (Array.isArray(result)) {
           cloneJSDocCommentsToNewNode(node, result[0]);
@@ -3574,10 +3250,8 @@ const getTransforms = (originalCode, scopeManager, opts) => {
           cloneJSDocCommentsToNewNode(node, result);
         }
       }
-
       return result;
     };
   }
-
   return [transform, code];
 };