flow-api-translator 0.37.0 → 0.328.0

package/dist/TSDefToFlowDef.js

@@ -4,21 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.TSDefToFlowDef = TSDefToFlowDef;
-
-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 _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 = null;
 const DUMMY_RANGE = [0, 0];
 const DUMMY_PARENT = null;
@@ -27,18 +18,17 @@ const DUMMY_COMMON = {
   range: DUMMY_RANGE,
   parent: DUMMY_PARENT
 };
-
 function constructFlowNode(node) {
-  return { ...node,
+  return {
+    ...node,
     ...DUMMY_COMMON
   };
 }
-
-const makeCommentOwnLine = _hermesTransform.makeCommentOwnLine;
-
+const makeCommentOwnLine = _flowTransform.makeCommentOwnLine;
 function TSDefToFlowDef(originalCode, ast, opts) {
   const flowBody = [];
-  const flowProgram = { ...DUMMY_COMMON,
+  const flowProgram = {
+    ...DUMMY_COMMON,
     type: 'Program',
     body: flowBody,
     comments: [],
@@ -49,41 +39,32 @@ function TSDefToFlowDef(originalCode, ast, opts) {
     docblock: null
   };
   const [transform, code] = getTransforms(originalCode, opts);
-
   for (const node of ast.body) {
     const result = transform.AllStatement(node);
     flowBody.push(...(Array.isArray(result) ? result : [result]));
   }
-
   return [flowProgram, code];
 }
-
 const getTransforms = (originalCode, 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,
@@ -95,31 +76,29 @@ const getTransforms = (originalCode, 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 = { ...DUMMY_COMMON,
+      const newNode = {
+        ...DUMMY_COMMON,
         type: 'AnyTypeAnnotation'
       };
       addErrorComment(newNode, codeFrame);
       return newNode;
     }
-
     throw translationError(node, message);
   }
-
   function unsupportedDeclaration(node, thing, id, typeParameters = null) {
     const message = unsupportedFeatureMessage(thing);
-
     if (opts.recoverFromErrors) {
       const codeFrame = buildCodeFrameForComment(node, message);
-      const newNode = { ...DUMMY_COMMON,
+      const newNode = {
+        ...DUMMY_COMMON,
         type: 'TypeAlias',
         id: Transform.Identifier(id, false),
-        right: { ...DUMMY_COMMON,
+        right: {
+          ...DUMMY_COMMON,
           type: 'AnyTypeAnnotation'
         },
         typeParameters: Transform.TSTypeParameterDeclarationOpt(typeParameters)
@@ -127,10 +106,8 @@ const getTransforms = (originalCode, opts) => {
       addErrorComment(newNode, codeFrame);
       return newNode;
     }
-
     throw translationError(node, message);
   }
-
   class Transform {
     static BlockStatement(node) {
       return constructFlowNode({
@@ -138,7 +115,6 @@ const getTransforms = (originalCode, opts) => {
         body: node.body.flatMap(node => Transform.Statement(node))
       });
     }
-
     static ClassDeclarationWithName(node) {
       return constructFlowNode({
         type: 'DeclareClass',
@@ -150,35 +126,27 @@ const getTransforms = (originalCode, opts) => {
         body: Transform.ClassDeclarationBody(node.body)
       });
     }
-
     static ClassDeclarationBody({
       body
     }) {
       const properties = [];
       const indexers = [];
-
       for (const classItem of body) {
         switch (classItem.type) {
           case 'StaticBlock':
             break;
-
           case 'TSIndexSignature':
             break;
-
           case 'TSAbstractPropertyDefinition':
           case 'PropertyDefinition':
             Transform._translateIntoObjectProp(classItem, properties, indexers);
-
             break;
-
           case 'MethodDefinition':
           case 'TSAbstractMethodDefinition':
             Transform._translateIntoObjectMethod(classItem, properties);
-
             break;
         }
       }
-
       return constructFlowNode({
         type: 'ObjectTypeAnnotation',
         properties,
@@ -189,47 +157,38 @@ const getTransforms = (originalCode, opts) => {
         inexact: false
       });
     }
-
     static ClassDeclarationSuperClass(superClass, superTypeArguments) {
       if (superClass == null) {
         return [];
       }
-
       const id = Transform._expressionToIdOrQualifiedTypeId(superClass, 'superClass');
-
       return [constructFlowNode({
         type: 'InterfaceExtends',
         id,
         typeParameters: Transform.TSTypeParameterInstantiationOpt(superTypeArguments)
       })];
     }
-
     static ClassImplements(node) {
       if (node.expression.type !== 'Identifier') {
         throw unexpectedTranslationError(node, 'Expected expression to be an Identifier');
       }
-
       return constructFlowNode({
         type: 'ClassImplements',
         id: Transform.Identifier(node.expression),
         typeParameters: Transform.TSTypeParameterInstantiationOpt(node.typeArguments)
       });
     }
-
     static DebuggerStatement() {
       return constructFlowNode({
         type: 'DebuggerStatement'
       });
     }
-
     static EntityNameToTypeIdentifier(node) {
       switch (node.type) {
         case 'Identifier':
           return Transform.Identifier(node);
-
         case 'TSQualifiedName':
           return Transform.TSQualifiedNameToQualifiedTypeIdentifier(node);
-
         case 'ThisExpression':
           return constructFlowNode({
             type: 'Identifier',
@@ -239,15 +198,12 @@ const getTransforms = (originalCode, opts) => {
           });
       }
     }
-
     static EntityNameToTypeofIdentifier(node) {
       switch (node.type) {
         case 'Identifier':
           return Transform.Identifier(node);
-
         case 'TSQualifiedName':
           return Transform.TSQualifiedNameToQualifiedTypeofIdentifier(node);
-
         case 'ThisExpression':
           return constructFlowNode({
             type: 'Identifier',
@@ -257,7 +213,6 @@ const getTransforms = (originalCode, opts) => {
           });
       }
     }
-
     static ExportAllDeclaration(node) {
       return constructFlowNode({
         type: 'ExportAllDeclaration',
@@ -272,34 +227,27 @@ const getTransforms = (originalCode, opts) => {
         exported: node.exported != null ? Transform.Identifier(node.exported) : null
       });
     }
-
     static ExportDefaultDeclaration(node) {
       let declaration;
-
       switch (node.declaration.type) {
         case 'ClassDeclaration':
           declaration = Transform.ClassDeclarationWithName(node.declaration);
           break;
-
         case 'FunctionDeclaration':
           declaration = Transform.FunctionDeclarationWithName(node.declaration);
           break;
-
         case 'TSDeclareFunction':
           declaration = Transform.TSDeclareFunction(node.declaration);
           break;
-
         case 'Identifier':
           declaration = constructFlowNode({
             type: 'TypeofTypeAnnotation',
             argument: Transform.Identifier(node.declaration)
           });
           break;
-
         default:
           throw translationError(node.declaration, `Unsupported export declaration: ${node.declaration.type}`);
       }
-
       return constructFlowNode({
         type: 'DeclareExportDeclaration',
         declaration,
@@ -308,7 +256,6 @@ const getTransforms = (originalCode, opts) => {
         specifiers: []
       });
     }
-
     static ExportNamedDeclaration(node) {
       if (node.declaration == null) {
         const source = node.source == null ? null : constructFlowNode({
@@ -330,7 +277,6 @@ const getTransforms = (originalCode, opts) => {
           specifiers
         });
       }
-
       switch (node.declaration.type) {
         case 'ClassDeclaration':
           return constructFlowNode({
@@ -340,7 +286,6 @@ const getTransforms = (originalCode, opts) => {
             source: null,
             specifiers: []
           });
-
         case 'FunctionDeclaration':
           return constructFlowNode({
             type: 'DeclareExportDeclaration',
@@ -349,7 +294,6 @@ const getTransforms = (originalCode, opts) => {
             source: null,
             specifiers: []
           });
-
         case 'TSDeclareFunction':
           return constructFlowNode({
             type: 'DeclareExportDeclaration',
@@ -358,18 +302,14 @@ const getTransforms = (originalCode, opts) => {
             source: null,
             specifiers: []
           });
-
         case 'TSEnumDeclaration':
           throw translationError(node.declaration, `Unsupported export declaration: ${node.declaration.type}`);
-
         case 'TSModuleDeclaration':
           {
             const decl = Transform.TSModuleDeclaration(node.declaration);
-
             if (decl.id.type !== 'Identifier') {
               throw translationError(decl.id, `Unsupported module declaration id`);
             }
-
             return [decl, constructFlowNode({
               type: 'ExportNamedDeclaration',
               declaration: null,
@@ -382,7 +322,6 @@ const getTransforms = (originalCode, opts) => {
               })]
             })];
           }
-
         case 'TSInterfaceDeclaration':
           {
             const decl = Transform.TSInterfaceDeclaration(node.declaration);
@@ -400,7 +339,6 @@ const getTransforms = (originalCode, opts) => {
               specifiers: []
             });
           }
-
         case 'TSTypeAliasDeclaration':
           {
             const decl = Transform.TSTypeAliasDeclaration(node.declaration);
@@ -412,7 +350,6 @@ const getTransforms = (originalCode, opts) => {
               specifiers: []
             });
           }
-
         case 'VariableDeclaration':
           {
             return Transform.VariableDeclaration(node.declaration).map(declaration => constructFlowNode({
@@ -425,16 +362,13 @@ const getTransforms = (originalCode, opts) => {
           }
       }
     }
-
     static FunctionDeclarationWithName(node) {
       var _node$returnType;
-
       const {
         thisParam,
         restParam,
         params
       } = Transform._partitionAndTranslateTSFunctionParams(node.params);
-
       const fnAnnot = constructFlowNode({
         type: 'FunctionTypeAnnotation',
         typeParameters: Transform.TSTypeParameterDeclarationOpt(node.typeParameters),
@@ -445,19 +379,21 @@ const getTransforms = (originalCode, opts) => {
       });
       return constructFlowNode({
         type: 'DeclareFunction',
-        id: { ...DUMMY_COMMON,
+        id: {
+          ...DUMMY_COMMON,
           type: 'Identifier',
           name: node.id.name,
-          typeAnnotation: { ...DUMMY_COMMON,
+          typeAnnotation: {
+            ...DUMMY_COMMON,
             type: 'TypeAnnotation',
             typeAnnotation: fnAnnot
           },
           optional: false
         },
+        implicitDeclare: false,
         predicate: null
       });
     }
-
     static Identifier(node, optional) {
       return constructFlowNode({
         type: 'Identifier',
@@ -466,24 +402,20 @@ const getTransforms = (originalCode, opts) => {
         optional: Boolean(optional != null ? optional : node.optional)
       });
     }
-
     static ImportDeclaration(node) {
       const specifiers = node.specifiers.map(specifier => {
         var _specifier$importKind;
-
         switch (specifier.type) {
           case 'ImportNamespaceSpecifier':
             return constructFlowNode({
               type: 'ImportNamespaceSpecifier',
               local: Transform.Identifier(specifier.local)
             });
-
           case 'ImportDefaultSpecifier':
             return constructFlowNode({
               type: 'ImportDefaultSpecifier',
               local: Transform.Identifier(specifier.local)
             });
-
           case 'ImportSpecifier':
             return constructFlowNode({
               type: 'ImportSpecifier',
@@ -506,21 +438,17 @@ const getTransforms = (originalCode, opts) => {
         specifiers
       });
     }
-
     static LabeledStatement(node) {
       const body = Transform.Statement(node.body);
-
       if (Array.isArray(body)) {
         throw translationError(node.body, 'Unexpected array of statements');
       }
-
       return constructFlowNode({
         type: 'LabeledStatement',
         label: Transform.Identifier(node.label),
         body
       });
     }
-
     static Literal(node) {
       if (typeof node.value === 'number') {
         return constructFlowNode({
@@ -570,10 +498,8 @@ const getTransforms = (originalCode, opts) => {
         throw translationError(node, `Unsupported literal type ${typeof node.value}`);
       }
     }
-
     static LiteralType(node) {
       const literal = Transform.Literal(node);
-
       switch (literal.literalType) {
         case 'boolean':
           return constructFlowNode({
@@ -581,21 +507,18 @@ const getTransforms = (originalCode, opts) => {
             value: literal.value,
             raw: literal.raw
           });
-
         case 'numeric':
           return constructFlowNode({
             type: 'NumberLiteralTypeAnnotation',
             value: literal.value,
             raw: literal.raw
           });
-
         case 'string':
           return constructFlowNode({
             type: 'StringLiteralTypeAnnotation',
             value: literal.value,
             raw: literal.raw
           });
-
         case 'bigint':
           return constructFlowNode({
             type: 'BigIntLiteralTypeAnnotation',
@@ -603,85 +526,61 @@ const getTransforms = (originalCode, opts) => {
             bigint: literal.bigint,
             raw: literal.raw
           });
-
         case 'null':
           return constructFlowNode({
             type: 'NullLiteralTypeAnnotation',
             value: literal.value,
             raw: literal.raw
           });
-
         case 'regexp':
           return unsupportedAnnotation(node, 'regexp literal type');
-
         default:
           literal;
           throw 'unreachable';
       }
     }
-
     static AllStatement(node) {
       switch (node.type) {
         case 'BlockStatement':
           return Transform.BlockStatement(node);
-
         case 'ClassDeclaration':
           return Transform.ClassDeclarationWithName(node);
-
         case 'DebuggerStatement':
           return Transform.DebuggerStatement();
-
         case 'ExportAllDeclaration':
           return Transform.ExportAllDeclaration(node);
-
         case 'ExportDefaultDeclaration':
           return Transform.ExportDefaultDeclaration(node);
-
         case 'ExportNamedDeclaration':
           return Transform.ExportNamedDeclaration(node);
-
         case 'FunctionDeclaration':
           return Transform.FunctionDeclarationWithName(node);
-
         case 'ImportDeclaration':
           return Transform.ImportDeclaration(node);
-
         case 'LabeledStatement':
           return Transform.LabeledStatement(node);
-
         case 'TSDeclareFunction':
           return Transform.TSDeclareFunction(node);
-
         case 'TSEnumDeclaration':
           return Transform.TSEnumDeclaration(node);
-
         case 'TSExportAssignment':
           return Transform.TSExportAssignment(node);
-
         case 'TSImportEqualsDeclaration':
           return Transform.TSImportEqualsDeclaration(node);
-
         case 'TSInterfaceDeclaration':
           return Transform.TSInterfaceDeclaration(node);
-
         case 'TSModuleDeclaration':
           return Transform.TSModuleDeclaration(node);
-
         case 'TSNamespaceExportDeclaration':
           return [];
-
         case 'TSTypeAliasDeclaration':
           return Transform.TSTypeAliasDeclaration(node);
-
         case 'VariableDeclaration':
           return Transform.VariableDeclaration(node);
-
         case 'ExpressionStatement':
           throw translationError(node, 'Unsupported expression statement');
-
         case 'WithStatement':
           throw translationError(node, 'Unsupported with statement');
-
         case 'BreakStatement':
         case 'ContinueStatement':
         case 'DoWhileStatement':
@@ -697,36 +596,30 @@ const getTransforms = (originalCode, opts) => {
           throw translationError(node, 'Unsupported control flow statement');
       }
     }
-
     static Statement(node) {
       return Transform.AllStatement(node);
     }
-
     static TSAnyType() {
       return constructFlowNode({
         type: 'AnyTypeAnnotation'
       });
     }
-
     static TSArrayType(node) {
       return constructFlowNode({
         type: 'ArrayTypeAnnotation',
         elementType: Transform.TSTypeAnnotation(node.elementType)
       });
     }
-
     static TSBigIntType() {
       return constructFlowNode({
         type: 'BigIntTypeAnnotation'
       });
     }
-
     static TSBooleanType() {
       return constructFlowNode({
         type: 'BooleanTypeAnnotation'
       });
     }
-
     static TSConditionalType(node) {
       return constructFlowNode({
         type: 'ConditionalTypeAnnotation',
@@ -736,26 +629,20 @@ const getTransforms = (originalCode, opts) => {
         falseType: Transform.TSTypeAnnotation(node.falseType)
       });
     }
-
     static TSConstructorType(node) {
       return unsupportedAnnotation(node, 'constructor types');
     }
-
     static TSDeclareFunction(node) {
       var _node$returnType2;
-
       if (node.id == null) {
         throw translationError(node, 'Missing function name');
       }
-
       const name = node.id.name;
-
       const {
         thisParam,
         restParam,
         params
       } = Transform._partitionAndTranslateTSFunctionParams(node.params);
-
       const fnAnnot = constructFlowNode({
         type: 'FunctionTypeAnnotation',
         typeParameters: Transform.TSTypeParameterDeclarationOpt(node.typeParameters),
@@ -766,26 +653,26 @@ const getTransforms = (originalCode, opts) => {
       });
       return constructFlowNode({
         type: 'DeclareFunction',
-        id: { ...DUMMY_COMMON,
+        id: {
+          ...DUMMY_COMMON,
           type: 'Identifier',
           name,
-          typeAnnotation: { ...DUMMY_COMMON,
+          typeAnnotation: {
+            ...DUMMY_COMMON,
             type: 'TypeAnnotation',
             typeAnnotation: fnAnnot
           },
           optional: false
         },
+        implicitDeclare: false,
         predicate: null
       });
     }
-
     static TSEnumDeclaration(node) {
       return unsupportedDeclaration(node, 'enums', node.id);
     }
-
     static TSExportAssignment(node) {
       let typeAnnotation;
-
       if (node.expression.type === 'Identifier') {
         typeAnnotation = constructFlowNode({
           type: 'TypeofTypeAnnotation',
@@ -796,7 +683,6 @@ const getTransforms = (originalCode, opts) => {
       } else {
         throw translationError(node, `Unsupported export assignment expression ${node.expression.type}`);
       }
-
       return constructFlowNode({
         type: 'DeclareModuleExports',
         typeAnnotation: constructFlowNode({
@@ -805,16 +691,13 @@ const getTransforms = (originalCode, opts) => {
         })
       });
     }
-
     static TSFunctionType(node, allowMissingReturn = false) {
       var _node$returnType3;
-
       const {
         thisParam,
         restParam,
         params
       } = Transform._partitionAndTranslateTSFunctionParams(node.params);
-
       return constructFlowNode({
         type: 'FunctionTypeAnnotation',
         typeParameters: Transform.TSTypeParameterDeclarationOpt(node.typeParameters),
@@ -826,16 +709,13 @@ const getTransforms = (originalCode, opts) => {
         this: thisParam
       });
     }
-
     static _partitionAndTranslateTSFunctionParams(tsParams) {
       const params = [...tsParams];
       const firstParam = params[0];
       let thisParam = null;
       let restParam = null;
-
       if (firstParam != null && firstParam.type === 'Identifier' && firstParam.name === 'this') {
         var _firstParam$typeAnnot;
-
         thisParam = constructFlowNode({
           type: 'FunctionTypeParam',
           name: constructFlowNode({
@@ -849,12 +729,9 @@ const getTransforms = (originalCode, opts) => {
         });
         params.shift();
       }
-
       const lastParam = params[params.length - 1];
-
       if (lastParam != null && lastParam.type === 'RestElement') {
         var _lastParam$typeAnnota;
-
         restParam = constructFlowNode({
           type: 'FunctionTypeParam',
           name: constructFlowNode({
@@ -868,14 +745,12 @@ const getTransforms = (originalCode, opts) => {
         });
         params.pop();
       }
-
       return {
         thisParam,
         restParam,
         params: params.map((param, i) => {
           if (param.type === 'Identifier') {
             var _param$typeAnnotation;
-
             return constructFlowNode({
               type: 'FunctionTypeParam',
               name: constructFlowNode({
@@ -889,7 +764,6 @@ const getTransforms = (originalCode, opts) => {
             });
           } else if (param.type === 'ArrayPattern' || param.type === 'ObjectPattern') {
             var _param$typeAnnotation2;
-
             return constructFlowNode({
               type: 'FunctionTypeParam',
               name: constructFlowNode({
@@ -907,20 +781,16 @@ const getTransforms = (originalCode, opts) => {
         })
       };
     }
-
     static TSImportType(node) {
       var _node$argument;
-
       const source = (_node$argument = node.argument) != null ? _node$argument : node.source == null ? null : {
         type: 'TSLiteralType',
         loc: node.source.loc,
         literal: node.source
       };
-
       if (source == null) {
         return unsupportedAnnotation(node, 'import types without a source');
       }
-
       let base = constructFlowNode({
         type: 'GenericTypeAnnotation',
         id: constructFlowNode({
@@ -934,25 +804,19 @@ const getTransforms = (originalCode, opts) => {
           params: [Transform.TSTypeAnnotation(source)]
         })
       });
-
       if (node.typeArguments != null) {
         return unsupportedAnnotation(node, 'import types with type arguments');
       }
-
       if (node.qualifier == null) {
         return base;
       }
-
       let qualifier = Transform.EntityNameToTypeIdentifier(node.qualifier);
       const namesRev = [];
-
       while (qualifier.type !== 'Identifier') {
         namesRev.push(qualifier.id.name);
         qualifier = qualifier.qualification;
       }
-
       namesRev.push(qualifier.name);
-
       while (namesRev.length > 0) {
         const name = namesRev.pop();
         base = constructFlowNode({
@@ -965,17 +829,13 @@ const getTransforms = (originalCode, opts) => {
           })
         });
       }
-
       return base;
     }
-
     static TSImportEqualsDeclaration(node) {
       if (node.moduleReference.type === 'ThisExpression' || node.moduleReference.type === 'TSQualifiedName') {
         return unsupportedDeclaration(node, 'import equals declaration with weird module reference', node.id);
       }
-
       let moduleName;
-
       if (node.moduleReference.type === 'TSExternalModuleReference') {
         if (node.moduleReference.expression.type === 'Literal') {
           moduleName = String(node.moduleReference.expression.value);
@@ -985,7 +845,6 @@ const getTransforms = (originalCode, opts) => {
       } else {
         moduleName = node.moduleReference.name;
       }
-
       return constructFlowNode({
         type: 'VariableDeclaration',
         kind: 'const',
@@ -1017,7 +876,6 @@ const getTransforms = (originalCode, opts) => {
         })]
       });
     }
-
     static TSIndexedAccessType(node) {
       return constructFlowNode({
         type: 'IndexedAccessType',
@@ -1025,14 +883,12 @@ const getTransforms = (originalCode, opts) => {
         indexType: Transform.TSTypeAnnotation(node.indexType)
       });
     }
-
     static TSInferType(node) {
       return constructFlowNode({
         type: 'InferTypeAnnotation',
         typeParameter: Transform.TSTypeParameter(node.typeParameter)
       });
     }
-
     static TSInterfaceDeclaration(node) {
       const body = Transform.TSTypeLiteralOrInterfaceBody(node.body);
       body.inexact = false;
@@ -1044,7 +900,6 @@ const getTransforms = (originalCode, opts) => {
         extends: (node.extends || []).map(e => Transform.TSInterfaceHeritage(e))
       });
     }
-
     static TSInterfaceHeritage(node) {
       return constructFlowNode({
         type: 'InterfaceExtends',
@@ -1052,7 +907,6 @@ const getTransforms = (originalCode, opts) => {
         typeParameters: Transform.TSTypeParameterInstantiationOpt(node.typeArguments)
       });
     }
-
     static _expressionToIdOrQualifiedTypeId(node, kind) {
       if (node.type === 'Identifier') {
         return Transform.Identifier(node);
@@ -1067,33 +921,26 @@ const getTransforms = (originalCode, opts) => {
         throw unexpectedTranslationError(node, `Expected ${kind} to be an Identifier or Member`);
       }
     }
-
     static TSIntersectionType(node) {
       return constructFlowNode({
         type: 'IntersectionTypeAnnotation',
         types: node.types.map(node => Transform.TSTypeAnnotation(node))
       });
     }
-
     static TSLiteralType(node) {
       switch (node.literal.type) {
         case 'TemplateLiteral':
           return unsupportedAnnotation(node, 'template literals');
-
         case 'Literal':
           return Transform.LiteralType(node.literal);
-
         case 'UnaryExpression':
           return unsupportedAnnotation(node, 'UnaryExpression literal type');
-
         case 'UpdateExpression':
           return unsupportedAnnotation(node, 'UpdateExpression literal type');
       }
     }
-
     static TSMappedType(node) {
       var _keyTparam$bound;
-
       const keyTparam = Transform.TSTypeParameter(node.typeParameter);
       const sourceType = (_keyTparam$bound = keyTparam.bound) == null ? void 0 : _keyTparam$bound.typeAnnotation;
       keyTparam.bound = null;
@@ -1118,10 +965,8 @@ const getTransforms = (originalCode, opts) => {
         inexact: false
       });
     }
-
     static TSModuleDeclaration(node) {
       var _node$global;
-
       const body = node.body == null ? constructFlowNode({
         type: 'BlockStatement',
         body: []
@@ -1131,7 +976,6 @@ const getTransforms = (originalCode, opts) => {
         type: 'BlockStatement',
         body: node.body.body.flatMap(s => Transform.Statement(s))
       });
-
       if (node.id.type === 'Literal') {
         return constructFlowNode({
           type: 'DeclareModule',
@@ -1139,22 +983,21 @@ const getTransforms = (originalCode, opts) => {
           body
         });
       }
-
       if ((_node$global = node.global) != null ? _node$global : false) {
         return unsupportedDeclaration(node, 'global declaration', node.id);
       }
-
       return constructFlowNode({
         type: 'DeclareNamespace',
+        global: false,
         id: Transform.Identifier(node.id),
-        body
+        body,
+        implicitDeclare: false,
+        keyword: 'namespace'
       });
     }
-
     static TSNamedTupleMember(node) {
       let optional = false;
       let elementType;
-
       if (node.elementType.type === 'TSRestType') {
         const child = node.elementType;
         return constructFlowNode({
@@ -1170,7 +1013,6 @@ const getTransforms = (originalCode, opts) => {
       } else {
         elementType = Transform.TSTypeAnnotation(node.elementType);
       }
-
       return constructFlowNode({
         type: 'TupleTypeLabeledElement',
         label: Transform.Identifier(node.label),
@@ -1179,25 +1021,21 @@ const getTransforms = (originalCode, opts) => {
         variance: null
       });
     }
-
     static TSNeverType() {
       return constructFlowNode({
         type: 'EmptyTypeAnnotation'
       });
     }
-
     static TSNullType() {
       return constructFlowNode({
         type: 'NullLiteralTypeAnnotation'
       });
     }
-
     static TSNumberType() {
       return constructFlowNode({
         type: 'NumberTypeAnnotation'
       });
     }
-
     static TSObjectType() {
       return constructFlowNode({
         type: 'InterfaceTypeAnnotation',
@@ -1213,7 +1051,6 @@ const getTransforms = (originalCode, opts) => {
         extends: []
       });
     }
-
     static TSQualifiedNameToQualifiedTypeIdentifier(node) {
       return constructFlowNode({
         type: 'QualifiedTypeIdentifier',
@@ -1221,7 +1058,6 @@ const getTransforms = (originalCode, opts) => {
         id: Transform.Identifier(node.right)
       });
     }
-
     static TSQualifiedNameToQualifiedTypeofIdentifier(node) {
       return constructFlowNode({
         type: 'QualifiedTypeofIdentifier',
@@ -1229,23 +1065,19 @@ const getTransforms = (originalCode, opts) => {
         id: Transform.Identifier(node.right)
       });
     }
-
     static TSStringType() {
       return constructFlowNode({
         type: 'StringTypeAnnotation'
       });
     }
-
     static TSSymbolType() {
       return constructFlowNode({
         type: 'SymbolTypeAnnotation'
       });
     }
-
     static TSTemplateLiteralType(node) {
       return unsupportedAnnotation(node, 'constructor types');
     }
-
     static TSThisType(_node) {
       return constructFlowNode({
         type: 'GenericTypeAnnotation',
@@ -1258,7 +1090,6 @@ const getTransforms = (originalCode, opts) => {
         typeParameters: null
       });
     }
-
     static TSTupleType(node) {
       return constructFlowNode({
         type: 'TupleTypeAnnotation',
@@ -1266,7 +1097,6 @@ const getTransforms = (originalCode, opts) => {
         inexact: false
       });
     }
-
     static TSTypeAliasDeclaration(node) {
       return constructFlowNode({
         type: 'TypeAlias',
@@ -1275,14 +1105,12 @@ const getTransforms = (originalCode, opts) => {
         right: Transform.TSTypeAnnotation(node.typeAnnotation)
       });
     }
-
     static TSTypeAnnotation(node) {
       switch (node.type) {
         case 'TSOptionalType':
         case 'TSQualifiedName':
         case 'TSRestType':
           return unsupportedAnnotation(node, 'unexpected toplevel ' + node.type);
-
         case 'TSAbstractKeyword':
         case 'TSAsyncKeyword':
         case 'TSDeclareKeyword':
@@ -1293,140 +1121,100 @@ const getTransforms = (originalCode, opts) => {
         case 'TSReadonlyKeyword':
         case 'TSStaticKeyword':
           return unsupportedAnnotation(node, 'wat keyword ' + node.type);
-
         case 'TSAnyKeyword':
           return Transform.TSAnyType();
-
         case 'TSArrayType':
           return Transform.TSArrayType(node);
-
         case 'TSBigIntKeyword':
           return Transform.TSBigIntType();
-
         case 'TSBooleanKeyword':
           return Transform.TSBooleanType();
-
         case 'TSConditionalType':
           return Transform.TSConditionalType(node);
-
         case 'TSConstructorType':
           return Transform.TSConstructorType(node);
-
         case 'TSFunctionType':
           return Transform.TSFunctionType(node);
-
         case 'TSImportType':
           return Transform.TSImportType(node);
-
         case 'TSIndexedAccessType':
           return Transform.TSIndexedAccessType(node);
-
         case 'TSInferType':
           return Transform.TSInferType(node);
-
         case 'TSIntersectionType':
           return Transform.TSIntersectionType(node);
-
         case 'TSIntrinsicKeyword':
           return unsupportedAnnotation(node, 'intrinsic keyword');
-
         case 'TSLiteralType':
           return Transform.TSLiteralType(node);
-
         case 'TSMappedType':
           return Transform.TSMappedType(node);
-
         case 'TSNamedTupleMember':
           return Transform.TSNamedTupleMember(node);
-
         case 'TSNeverKeyword':
           return Transform.TSNeverType();
-
         case 'TSNullKeyword':
           return Transform.TSNullType();
-
         case 'TSNumberKeyword':
           return Transform.TSNumberType();
-
         case 'TSObjectKeyword':
           return Transform.TSObjectType();
-
         case 'TSStringKeyword':
           return Transform.TSStringType();
-
         case 'TSSymbolKeyword':
           return Transform.TSSymbolType();
-
         case 'TSTemplateLiteralType':
           return Transform.TSTemplateLiteralType(node);
-
         case 'TSThisType':
           return Transform.TSThisType(node);
-
         case 'TSTupleType':
           return Transform.TSTupleType(node);
-
         case 'TSTypeLiteral':
           return Transform.TSTypeLiteralOrInterfaceBody(node);
-
         case 'TSTypeOperator':
           return Transform.TSTypeOperator(node);
-
         case 'TSTypePredicate':
           return Transform.TSTypePredicate(node);
-
         case 'TSTypeQuery':
           return Transform.TSTypeQuery(node);
-
         case 'TSTypeReference':
           return Transform.TSTypeReference(node);
-
         case 'TSUndefinedKeyword':
         case 'TSVoidKeyword':
           return Transform.TSUndefinedOrVoidType();
-
         case 'TSUnionType':
           return Transform.TSUnionType(node);
-
         case 'TSUnknownKeyword':
           return Transform.TSUnknownType();
       }
     }
-
     static TSTypeAnnotationOpt(node) {
       return node == null ? constructFlowNode({
         type: 'AnyTypeAnnotation'
       }) : Transform.TSTypeAnnotation(node);
     }
-
     static TSTypeAnnotationNode(node) {
       return constructFlowNode({
         type: 'TypeAnnotation',
         typeAnnotation: Transform.TSTypeAnnotation(node.typeAnnotation)
       });
     }
-
     static TSTypeLiteralOrInterfaceBody(node) {
       const properties = [];
       const indexers = [];
       const callProperties = [];
-
       for (const prop of node.type === 'TSTypeLiteral' ? node.members : node.body) {
         switch (prop.type) {
           case 'TSPropertySignature':
             {
               Transform._translateIntoObjectProp(prop, properties, indexers);
-
               break;
             }
-
           case 'TSMethodSignature':
             {
               Transform._translateIntoObjectMethod(prop, properties);
-
               break;
             }
-
           case 'TSCallSignatureDeclaration':
             callProperties.push(constructFlowNode({
               type: 'ObjectTypeCallProperty',
@@ -1444,11 +1232,9 @@ const getTransforms = (originalCode, opts) => {
               })
             }));
             break;
-
           case 'TSIndexSignature':
             {
               var _prop$typeAnnotation;
-
               const variance = Boolean(prop.readonly) ? constructFlowNode({
                 type: 'Variance',
                 kind: 'plus'
@@ -1469,7 +1255,6 @@ const getTransforms = (originalCode, opts) => {
               }));
               break;
             }
-
           case 'TSConstructSignatureDeclaration':
             properties.push(constructFlowNode({
               type: 'ObjectTypeProperty',
@@ -1496,7 +1281,6 @@ const getTransforms = (originalCode, opts) => {
             break;
         }
       }
-
       return constructFlowNode({
         type: 'ObjectTypeAnnotation',
         properties,
@@ -1507,16 +1291,13 @@ const getTransforms = (originalCode, opts) => {
         inexact: true
       });
     }
-
     static _translateIntoObjectProp(prop, properties, indexers) {
       const variance = Boolean(prop.readonly) ? constructFlowNode({
         type: 'Variance',
         kind: 'plus'
       }) : null;
-
       if (prop.computed === false) {
         var _prop$typeAnnotation2;
-
         const key = prop.key;
         properties.push(constructFlowNode({
           type: 'ObjectTypeProperty',
@@ -1539,7 +1320,6 @@ const getTransforms = (originalCode, opts) => {
         }));
       } else {
         var _prop$typeAnnotation3;
-
         indexers.push(constructFlowNode({
           type: 'ObjectTypeIndexer',
           kind: 'init',
@@ -1556,12 +1336,10 @@ const getTransforms = (originalCode, opts) => {
         }));
       }
     }
-
     static _translateIntoObjectMethod(prop, properties) {
       if (prop.computed === true) {
         throw translationError(prop, 'computed method signature');
       }
-
       const originalKey = prop.key;
       const key = originalKey.type === 'Identifier' ? Transform.Identifier(originalKey, false) : originalKey.type === 'PrivateIdentifier' ? constructFlowNode({
         type: 'PrivateIdentifier',
@@ -1579,7 +1357,6 @@ const getTransforms = (originalCode, opts) => {
         returnType: prop.type === 'MethodDefinition' || prop.type === 'TSAbstractMethodDefinition' ? prop.value.returnType : prop.returnType,
         typeParameters: prop.typeParameters
       }, true);
-
       if (prop.kind === 'method' || prop.kind === 'constructor') {
         properties.push(constructFlowNode({
           type: 'ObjectTypeProperty',
@@ -1606,22 +1383,18 @@ const getTransforms = (originalCode, opts) => {
         }));
       }
     }
-
     static TSTypeOperator(node) {
       switch (node.operator) {
         case 'unique':
           return unsupportedAnnotation(node, 'unique operator');
-
         case 'keyof':
           return constructFlowNode({
             type: 'KeyofTypeAnnotation',
             argument: Transform.TSTypeAnnotationOpt(node.typeAnnotation)
           });
-
         case 'readonly':
           {
             const child = node.typeAnnotation;
-
             switch (child == null ? void 0 : child.type) {
               case 'TSArrayType':
                 return constructFlowNode({
@@ -1637,7 +1410,6 @@ const getTransforms = (originalCode, opts) => {
                     params: [Transform.TSTypeAnnotation(child.elementType)]
                   })
                 });
-
               case 'TSTupleType':
                 return constructFlowNode({
                   type: 'GenericTypeAnnotation',
@@ -1652,14 +1424,12 @@ const getTransforms = (originalCode, opts) => {
                     params: [Transform.TSTypeAnnotation(child)]
                   })
                 });
-
               default:
                 return unsupportedAnnotation(node, 'readonly operator with inner type: ' + ((child == null ? void 0 : child.type) || 'null'));
             }
           }
       }
     }
-
     static TSTypeParameter(node) {
       return constructFlowNode({
         type: 'TypeParameter',
@@ -1677,29 +1447,24 @@ const getTransforms = (originalCode, opts) => {
         })
       });
     }
-
     static TSTypeParameterDeclaration(node) {
       return constructFlowNode({
         type: 'TypeParameterDeclaration',
         params: node.params.map(node => Transform.TSTypeParameter(node))
       });
     }
-
     static TSTypeParameterDeclarationOpt(node) {
       return node != null ? Transform.TSTypeParameterDeclaration(node) : null;
     }
-
     static TSTypeParameterInstantiation(node) {
       return constructFlowNode({
         type: 'TypeParameterInstantiation',
         params: node.params.map(node => Transform.TSTypeAnnotation(node))
       });
     }
-
     static TSTypeParameterInstantiationOpt(node) {
       return node != null ? Transform.TSTypeParameterInstantiation(node) : null;
     }
-
     static TSTypePredicate(node) {
       return constructFlowNode({
         type: 'TypePredicate',
@@ -1713,25 +1478,20 @@ const getTransforms = (originalCode, opts) => {
         typeAnnotation: node.typeAnnotation == null ? null : Transform.TSTypeAnnotation(node.typeAnnotation.typeAnnotation)
       });
     }
-
     static TSTypeQuery(node) {
       var _Transform$TSTypePara;
-
       if (node.exprName.type === 'TSImportType') {
         if (node.typeArguments != null) {
           return unsupportedAnnotation(node, 'type query imports with type arguments');
         }
-
         return Transform.TSImportType(node.exprName);
       }
-
       return constructFlowNode({
         type: 'TypeofTypeAnnotation',
         argument: Transform.EntityNameToTypeofIdentifier(node.exprName),
         typeArguments: (_Transform$TSTypePara = Transform.TSTypeParameterInstantiationOpt(node.typeArguments)) != null ? _Transform$TSTypePara : undefined
       });
     }
-
     static TSTypeReference(node) {
       return constructFlowNode({
         type: 'GenericTypeAnnotation',
@@ -1739,34 +1499,28 @@ const getTransforms = (originalCode, opts) => {
         typeParameters: Transform.TSTypeParameterInstantiationOpt(node.typeArguments)
       });
     }
-
     static TSUndefinedOrVoidType() {
       return constructFlowNode({
         type: 'VoidTypeAnnotation'
       });
     }
-
     static TSUnionType(node) {
       return constructFlowNode({
         type: 'UnionTypeAnnotation',
         types: node.types.map(node => Transform.TSTypeAnnotation(node))
       });
     }
-
     static TSUnknownType() {
       return constructFlowNode({
         type: 'MixedTypeAnnotation'
       });
     }
-
     static VariableDeclaration(node) {
       return node.declarations.map(decl => {
         if (decl.id.type !== 'Identifier') {
           throw translationError(decl.id, 'Non-identifier variable declaration');
         }
-
         const id = Transform.Identifier(decl.id);
-
         if (id.typeAnnotation == null) {
           id.typeAnnotation = constructFlowNode({
             type: 'TypeAnnotation',
@@ -1775,16 +1529,18 @@ const getTransforms = (originalCode, opts) => {
             })
           });
         }
-
         return constructFlowNode({
           type: 'DeclareVariable',
-          id,
-          kind: node.kind
+          declarations: [constructFlowNode({
+            type: 'VariableDeclarator',
+            id,
+            init: null
+          })],
+          kind: node.kind,
+          implicitDeclare: false
         });
       });
     }
-
   }
-
   return [Transform, code];
 };