flow-parser 0.317.0 → 0.319.0

package/oxidized/generated/ESTreeVisitorKeys.js

@@ -0,0 +1,234 @@
+'use strict';
+
+module.exports = {
+  AbstractMethodDefinition: ['key', 'value'],
+  AbstractPropertyDefinition: ['key', 'value', 'variance'],
+  AnyTypeAnnotation: [],
+  ArrayExpression: ['elements'],
+  ArrayPattern: ['elements', 'typeAnnotation'],
+  ArrayTypeAnnotation: ['elementType'],
+  ArrowFunctionExpression: ['params', 'body', 'typeParameters', 'returnType', 'predicate'],
+  AsConstExpression: ['expression'],
+  AsExpression: ['expression', 'typeAnnotation'],
+  AssignmentExpression: ['left', 'right'],
+  AssignmentPattern: ['left', 'right'],
+  AwaitExpression: ['argument'],
+  BigIntLiteralTypeAnnotation: [],
+  BigIntTypeAnnotation: [],
+  BinaryExpression: ['left', 'right'],
+  BlockStatement: ['body'],
+  BooleanLiteralTypeAnnotation: [],
+  BooleanTypeAnnotation: [],
+  BreakStatement: ['label'],
+  CallExpression: ['callee', 'typeArguments', 'arguments'],
+  CatchClause: ['param', 'body'],
+  ChainExpression: ['expression'],
+  ClassBody: ['body'],
+  ClassDeclaration: ['id', 'typeParameters', 'superClass', 'superTypeArguments', 'implements', 'decorators', 'body'],
+  ClassExpression: ['id', 'typeParameters', 'superClass', 'superTypeArguments', 'implements', 'decorators', 'body'],
+  ClassImplements: ['id', 'typeParameters'],
+  ComponentDeclaration: ['id', 'params', 'body', 'typeParameters', 'rendersType'],
+  ComponentParameter: ['name', 'local'],
+  ComponentTypeAnnotation: ['params', 'rest', 'typeParameters', 'rendersType'],
+  ComponentTypeParameter: ['name', 'typeAnnotation'],
+  ConditionalExpression: ['test', 'consequent', 'alternate'],
+  ConditionalTypeAnnotation: ['checkType', 'extendsType', 'trueType', 'falseType'],
+  ConstructorTypeAnnotation: ['params', 'returnType', 'rest', 'typeParameters'],
+  ContinueStatement: ['label'],
+  DebuggerStatement: [],
+  DeclareClass: ['id', 'typeParameters', 'extends', 'implements', 'mixins', 'body'],
+  DeclareClassExtendsCall: ['callee', 'argument'],
+  DeclareComponent: ['id', 'params', 'rest', 'typeParameters', 'rendersType'],
+  DeclareEnum: ['id', 'body'],
+  DeclareExportAllDeclaration: ['source'],
+  DeclareExportDeclaration: ['declaration', 'specifiers', 'source'],
+  DeclareFunction: ['id', 'predicate'],
+  DeclareHook: ['id'],
+  DeclareInterface: ['id', 'typeParameters', 'extends', 'body'],
+  DeclareMethodDefinition: ['key', 'value'],
+  DeclareModule: ['id', 'body'],
+  DeclareModuleExports: ['typeAnnotation'],
+  DeclareNamespace: ['id', 'body'],
+  DeclareOpaqueType: ['id', 'typeParameters', 'impltype', 'lowerBound', 'upperBound', 'supertype'],
+  DeclareTypeAlias: ['id', 'typeParameters', 'right'],
+  DeclareVariable: ['id'],
+  DeclaredPredicate: ['value'],
+  Decorator: ['expression'],
+  DoWhileStatement: ['body', 'test'],
+  EmptyStatement: [],
+  EmptyTypeAnnotation: [],
+  EnumBigIntBody: ['members'],
+  EnumBigIntMember: ['id', 'init'],
+  EnumBody: ['members'],
+  EnumBooleanBody: ['members'],
+  EnumBooleanMember: ['id', 'init'],
+  EnumDeclaration: ['id', 'body'],
+  EnumDefaultedMember: ['id'],
+  EnumNumberBody: ['members'],
+  EnumNumberMember: ['id', 'init'],
+  EnumStringBody: ['members'],
+  EnumStringMember: ['id', 'init'],
+  EnumSymbolBody: ['members'],
+  ExistsTypeAnnotation: [],
+  ExportAllDeclaration: ['exported', 'source'],
+  ExportAssignment: ['expression'],
+  ExportDefaultDeclaration: ['declaration'],
+  ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
+  ExportNamespaceSpecifier: ['exported'],
+  ExportSpecifier: ['exported', 'local'],
+  ExpressionStatement: ['expression'],
+  ExternalModuleReference: ['expression'],
+  ForInStatement: ['left', 'right', 'body'],
+  ForOfStatement: ['left', 'right', 'body'],
+  ForStatement: ['init', 'test', 'update', 'body'],
+  FunctionDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
+  FunctionExpression: ['id', 'params', 'body', 'typeParameters', 'returnType', 'predicate'],
+  FunctionTypeAnnotation: ['params', 'this', 'returnType', 'rest', 'typeParameters'],
+  FunctionTypeParam: ['name', 'typeAnnotation'],
+  GenericTypeAnnotation: ['id', 'typeParameters'],
+  HookDeclaration: ['id', 'params', 'body', 'typeParameters', 'returnType'],
+  HookTypeAnnotation: ['params', 'returnType', 'rest', 'typeParameters'],
+  Identifier: ['typeAnnotation'],
+  IfStatement: ['test', 'consequent', 'alternate'],
+  ImportAttribute: ['key', 'value'],
+  ImportDeclaration: ['specifiers', 'source', 'attributes'],
+  ImportDefaultSpecifier: ['local'],
+  ImportEqualsDeclaration: ['id', 'moduleReference'],
+  ImportExpression: ['source', 'options'],
+  ImportNamespaceSpecifier: ['local'],
+  ImportSpecifier: ['imported', 'local'],
+  ImportType: ['argument'],
+  IndexedAccessType: ['objectType', 'indexType'],
+  InferTypeAnnotation: ['typeParameter'],
+  InferredPredicate: [],
+  InterfaceDeclaration: ['id', 'typeParameters', 'extends', 'body'],
+  InterfaceExtends: ['id', 'typeParameters'],
+  InterfaceTypeAnnotation: ['extends', 'body'],
+  InterpreterDirective: [],
+  IntersectionTypeAnnotation: ['types'],
+  JSXAttribute: ['name', 'value'],
+  JSXClosingElement: ['name'],
+  JSXClosingFragment: [],
+  JSXElement: ['openingElement', 'children', 'closingElement'],
+  JSXEmptyExpression: [],
+  JSXExpressionContainer: ['expression'],
+  JSXFragment: ['openingFragment', 'children', 'closingFragment'],
+  JSXIdentifier: [],
+  JSXMemberExpression: ['object', 'property'],
+  JSXNamespacedName: ['namespace', 'name'],
+  JSXOpeningElement: ['name', 'attributes', 'typeArguments'],
+  JSXOpeningFragment: [],
+  JSXSpreadAttribute: ['argument'],
+  JSXSpreadChild: ['expression'],
+  JSXText: [],
+  KeyofTypeAnnotation: ['argument'],
+  LabeledStatement: ['label', 'body'],
+  LogicalExpression: ['left', 'right'],
+  MatchArrayPattern: ['elements', 'rest'],
+  MatchAsPattern: ['pattern', 'target'],
+  MatchBindingPattern: ['id'],
+  MatchExpression: ['argument', 'cases'],
+  MatchExpressionCase: ['pattern', 'body', 'guard'],
+  MatchIdentifierPattern: ['id'],
+  MatchInstanceObjectPattern: ['properties', 'rest'],
+  MatchInstancePattern: ['targetConstructor', 'properties'],
+  MatchLiteralPattern: ['literal'],
+  MatchMemberPattern: ['base', 'property'],
+  MatchObjectPattern: ['properties', 'rest'],
+  MatchObjectPatternProperty: ['key', 'pattern'],
+  MatchOrPattern: ['patterns'],
+  MatchRestPattern: ['argument'],
+  MatchStatement: ['argument', 'cases'],
+  MatchStatementCase: ['pattern', 'body', 'guard'],
+  MatchUnaryPattern: ['argument'],
+  MatchWildcardPattern: [],
+  MemberExpression: ['object', 'property'],
+  MetaProperty: ['meta', 'property'],
+  MethodDefinition: ['key', 'value', 'decorators'],
+  MixedTypeAnnotation: [],
+  NamespaceExportDeclaration: ['id'],
+  NeverTypeAnnotation: [],
+  NewExpression: ['callee', 'typeArguments', 'arguments'],
+  NonNullExpression: ['argument'],
+  NullLiteralTypeAnnotation: [],
+  NullableTypeAnnotation: ['typeAnnotation'],
+  NumberLiteralTypeAnnotation: [],
+  NumberTypeAnnotation: [],
+  ObjectExpression: ['properties'],
+  ObjectPattern: ['properties', 'typeAnnotation'],
+  ObjectTypeAnnotation: ['properties', 'indexers', 'callProperties', 'internalSlots'],
+  ObjectTypeCallProperty: ['value'],
+  ObjectTypeIndexer: ['id', 'key', 'value', 'variance'],
+  ObjectTypeInternalSlot: ['id', 'value'],
+  ObjectTypeMappedTypeProperty: ['keyTparam', 'propType', 'sourceType', 'variance'],
+  ObjectTypePrivateField: ['key'],
+  ObjectTypeProperty: ['key', 'value', 'variance'],
+  ObjectTypeSpreadProperty: ['argument'],
+  OpaqueType: ['id', 'typeParameters', 'impltype', 'lowerBound', 'upperBound', 'supertype'],
+  OptionalIndexedAccessType: ['objectType', 'indexType'],
+  ParameterProperty: ['key', 'value', 'typeAnnotation', 'variance', 'decorators'],
+  PrivateIdentifier: [],
+  Program: ['body'],
+  Property: ['key', 'value'],
+  PropertyDefinition: ['key', 'value', 'decorators', 'variance', 'typeAnnotation'],
+  QualifiedTypeIdentifier: ['qualification', 'id'],
+  QualifiedTypeofIdentifier: ['qualification', 'id'],
+  RecordDeclaration: ['id', 'typeParameters', 'implements', 'body'],
+  RecordDeclarationBody: ['elements'],
+  RecordDeclarationImplements: ['id', 'typeArguments'],
+  RecordDeclarationProperty: ['key', 'typeAnnotation', 'defaultValue'],
+  RecordDeclarationStaticProperty: ['key', 'typeAnnotation', 'value'],
+  RecordExpression: ['recordConstructor', 'typeArguments', 'properties'],
+  RecordExpressionProperties: ['properties'],
+  RendersMaybeType: ['argument'],
+  RendersStarType: ['argument'],
+  RendersType: ['argument'],
+  RestElement: ['argument'],
+  ReturnStatement: ['argument'],
+  SatisfiesExpression: ['expression', 'typeAnnotation'],
+  SequenceExpression: ['expressions'],
+  SpreadElement: ['argument'],
+  StaticBlock: ['body'],
+  StringLiteralTypeAnnotation: [],
+  StringTypeAnnotation: [],
+  Super: [],
+  SwitchCase: ['test', 'consequent'],
+  SwitchStatement: ['discriminant', 'cases'],
+  SymbolTypeAnnotation: [],
+  TaggedTemplateExpression: ['tag', 'quasi'],
+  TemplateElement: [],
+  TemplateLiteral: ['quasis', 'expressions'],
+  TemplateLiteralTypeAnnotation: ['quasis', 'types'],
+  ThisExpression: [],
+  ThisTypeAnnotation: [],
+  ThrowStatement: ['argument'],
+  TryStatement: ['block', 'handler', 'finalizer'],
+  TupleTypeAnnotation: ['elementTypes'],
+  TupleTypeElement: ['elementType'],
+  TupleTypeLabeledElement: ['label', 'elementType', 'variance'],
+  TupleTypeSpreadElement: ['label', 'typeAnnotation'],
+  TypeAlias: ['id', 'typeParameters', 'right'],
+  TypeAnnotation: ['typeAnnotation'],
+  TypeCastExpression: ['expression', 'typeAnnotation'],
+  TypeOperator: ['typeAnnotation'],
+  TypeParameter: ['bound', 'variance', 'default'],
+  TypeParameterDeclaration: ['params'],
+  TypeParameterInstantiation: ['params'],
+  TypePredicate: ['parameterName', 'typeAnnotation'],
+  TypeofTypeAnnotation: ['argument', 'typeArguments'],
+  UnaryExpression: ['argument'],
+  UndefinedTypeAnnotation: [],
+  UnionTypeAnnotation: ['types'],
+  UnknownTypeAnnotation: [],
+  UpdateExpression: ['argument'],
+  VariableDeclaration: ['declarations'],
+  VariableDeclarator: ['id', 'init'],
+  Variance: [],
+  VoidTypeAnnotation: [],
+  WhileStatement: ['test', 'body'],
+  WithStatement: ['object', 'body'],
+  YieldExpression: ['argument'],
+  OptionalMemberExpression: ['object', 'property'],
+  OptionalCallExpression: ['callee', 'typeArguments', 'arguments'],
+  Literal: []
+};

package/oxidized/generated/ESTreeVisitorKeys.js.flow

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ * @generated
+ */
+
+/*
+ * !!! GENERATED FILE !!!
+ *
+ * Any manual changes to this file will be overwritten. To regenerate run `buck run fbcode//flow/rust_port/crates/flow_parser_wasm:codegen -- --estree-visitor-keys-flow`.
+ */
+
+'use strict';
+
+export type VisitorKeys = Readonly<{[string]: ReadonlyArray<string>}>;
+
+declare module.exports: VisitorKeys;

package/oxidized/getModuleDocblock.js

@@ -0,0 +1,87 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getModuleDocblock = getModuleDocblock;
+exports.parseDocblockString = parseDocblockString;
+const DIRECTIVE_REGEX = /^\s*@([a-zA-Z0-9_-]+)( +.+)?$/;
+
+function parseDocblockString(docblock) {
+  const directiveLines = docblock.split('\n').map(line => line.trimStart().replace(/^\* ?/, '').trim()).filter(line => line.startsWith('@'));
+  const directives = Object.create(null);
+
+  for (const line of directiveLines) {
+    var _match$;
+
+    const match = DIRECTIVE_REGEX.exec(line);
+
+    if (match == null) {
+      continue;
+    }
+
+    const name = match[1];
+    const value = ((_match$ = match[2]) != null ? _match$ : '').trim();
+
+    if (directives[name]) {
+      directives[name].push(value);
+    } else {
+      directives[name] = [value];
+    }
+  }
+
+  return directives;
+}
+
+function getModuleDocblock(hermesProgram) {
+  const docblockNode = (() => {
+    if (hermesProgram.type !== 'Program') {
+      return null;
+    }
+
+    const program = hermesProgram;
+
+    if (program.comments.length === 0) {
+      return null;
+    }
+
+    const firstComment = (() => {
+      const first = program.comments[0];
+
+      if (first.type === 'Block') {
+        return first;
+      }
+
+      if (program.comments.length === 1) {
+        return null;
+      }
+
+      const second = program.comments[1];
+
+      if (first.type === 'Line' && first.range[0] === 0 && second.type === 'Block') {
+        return second;
+      }
+
+      return null;
+    })();
+
+    if (firstComment == null) {
+      return null;
+    }
+
+    if (program.body.length > 0 && program.body[0].range[0] < firstComment.range[0]) {
+      return null;
+    }
+
+    return firstComment;
+  })();
+
+  if (docblockNode == null) {
+    return null;
+  }
+
+  return {
+    directives: parseDocblockString(docblockNode.value),
+    comment: docblockNode
+  };
+}

package/oxidized/getModuleDocblock.js.flow

@@ -0,0 +1,119 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ * @format
+ */
+
+'use strict';
+
+import type {HermesNode} from './HermesAST';
+import type {FlowParserProgram} from './FlowParserDeserializer';
+import type {DocblockDirectives, Program} from 'hermes-estree';
+
+const DIRECTIVE_REGEX = /^\s*@([a-zA-Z0-9_-]+)( +.+)?$/;
+
+export function parseDocblockString(docblock: string): DocblockDirectives {
+  const directiveLines = docblock
+    .split('\n')
+    // remove the leading " *" from each line
+    .map(line => line.trimStart().replace(/^\* ?/, '').trim())
+    .filter(line => line.startsWith('@'));
+
+  const directives: {
+    [string]: Array<string>,
+  } =
+    // $FlowExpectedError[incompatible-type] - flow types  this return as {...}
+    Object.create(null);
+
+  for (const line of directiveLines) {
+    const match = DIRECTIVE_REGEX.exec(line);
+    if (match == null) {
+      continue;
+    }
+    const name = match[1];
+    // explicitly use an empty string if there's no value
+    // this way the array length tracks how many instances of the directive there was
+    const value = (match[2] ?? '').trim();
+    if (directives[name]) {
+      directives[name].push(value);
+    } else {
+      directives[name] = [value];
+    }
+  }
+
+  return directives;
+}
+
+export function getModuleDocblock(
+  hermesProgram: HermesNode | FlowParserProgram,
+): Program['docblock'] {
+  const docblockNode = (() => {
+    if (hermesProgram.type !== 'Program') {
+      return null;
+    }
+
+    // $FlowExpectedError[incompatible-type] - escape out of the unsafe hermes types
+    const program: Program = hermesProgram;
+
+    if (program.comments.length === 0) {
+      return null;
+    }
+
+    const firstComment = (() => {
+      const first = program.comments[0];
+      if (first.type === 'Block') {
+        return first;
+      }
+
+      if (program.comments.length === 1) {
+        return null;
+      }
+
+      // ESLint will always strip out the shebang comment from the code before passing it to the parser
+      // https://github.com/eslint/eslint/blob/21d647904dc30f9484b22acdd9243a6d0ecfba38/lib/linter/linter.js#L779
+      // this means that we're forced to parse it as a line comment :(
+      // this hacks around it by selecting the second comment in this case
+      const second = program.comments[1];
+      if (
+        first.type === 'Line' &&
+        first.range[0] === 0 &&
+        second.type === 'Block'
+      ) {
+        return second;
+      }
+
+      return null;
+    })();
+    if (firstComment == null) {
+      return null;
+    }
+
+    /*
+    Handle cases like this where the comment isn't actually the first thing in the code:
+    ```
+    const x = 1; /* docblock *./
+    ```
+    */
+    if (
+      program.body.length > 0 &&
+      program.body[0].range[0] < firstComment.range[0]
+    ) {
+      return null;
+    }
+
+    return firstComment;
+  })();
+
+  if (docblockNode == null) {
+    return null;
+  }
+
+  return {
+    directives: parseDocblockString(docblockNode.value),
+    comment: docblockNode,
+  };
+}

package/oxidized/index.js

@@ -0,0 +1,220 @@
+'use strict';
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  parse: true,
+  mutateESTreeASTForPrettier: true,
+  Transforms: true,
+  FlowVisitorKeys: true,
+  astArrayMutationHelpers: true,
+  astNodeMutationHelpers: true
+};
+exports.mutateESTreeASTForPrettier = exports.astNodeMutationHelpers = exports.astArrayMutationHelpers = exports.Transforms = void 0;
+exports.parse = parse;
+
+var FlowParser = _interopRequireWildcard(require("./FlowParser"));
+
+var _ESTreeVisitorKeys = _interopRequireDefault(require("./generated/ESTreeVisitorKeys"));
+
+exports.FlowVisitorKeys = _ESTreeVisitorKeys.default;
+
+var TransformComponentSyntax = _interopRequireWildcard(require("./estree/TransformComponentSyntax"));
+
+var TransformEnumSyntax = _interopRequireWildcard(require("./estree/TransformEnumSyntax"));
+
+var TransformMatchSyntax = _interopRequireWildcard(require("./estree/TransformMatchSyntax"));
+
+var TransformRecordSyntax = _interopRequireWildcard(require("./estree/TransformRecordSyntax"));
+
+var StripFlowTypesForBabel = _interopRequireWildcard(require("./estree/StripFlowTypesForBabel"));
+
+var TransformESTreeToBabel = _interopRequireWildcard(require("./babel/TransformESTreeToBabel"));
+
+var StripFlowTypes = _interopRequireWildcard(require("./estree/StripFlowTypes"));
+
+var _ParserOptions = require("./ParserOptions");
+
+Object.keys(_ParserOptions).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ParserOptions[key]) return;
+  exports[key] = _ParserOptions[key];
+});
+
+var _SimpleTraverser = require("./traverse/SimpleTraverser");
+
+Object.keys(_SimpleTraverser).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTraverser[key]) return;
+  exports[key] = _SimpleTraverser[key];
+});
+
+var _SimpleTransform = require("./transform/SimpleTransform");
+
+Object.keys(_SimpleTransform).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _SimpleTransform[key]) return;
+  exports[key] = _SimpleTransform[key];
+});
+
+var _getVisitorKeys = require("./traverse/getVisitorKeys");
+
+Object.keys(_getVisitorKeys).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _getVisitorKeys[key]) return;
+  exports[key] = _getVisitorKeys[key];
+});
+
+var _astArrayMutationHelpers = _interopRequireWildcard(require("./transform/astArrayMutationHelpers"));
+
+exports.astArrayMutationHelpers = _astArrayMutationHelpers;
+
+var _astNodeMutationHelpers = _interopRequireWildcard(require("./transform/astNodeMutationHelpers"));
+
+exports.astNodeMutationHelpers = _astNodeMutationHelpers;
+
+var _mutateESTreeASTForPrettier = _interopRequireDefault(require("./utils/mutateESTreeASTForPrettier"));
+
+exports.mutateESTreeASTForPrettier = _mutateESTreeASTForPrettier.default;
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    default: obj
+  };
+}
+
+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;
+}
+
+const DEFAULTS = {
+  flow: 'detect'
+};
+
+function getOptions(opts) {
+  const options = { ...DEFAULTS,
+    ...(opts != null ? opts : {})
+  };
+
+  if (options.flow !== 'all' && options.flow !== 'detect') {
+    throw new Error('flow option must be "all" or "detect"');
+  }
+
+  if (options.sourceType === 'unambiguous') {
+    delete options.sourceType;
+  } else if (options.sourceType != null && options.sourceType !== 'script' && options.sourceType !== 'module') {
+    throw new Error('sourceType option must be "script", "module", or "unambiguous" if set');
+  }
+
+  if (options.enableExperimentalComponentSyntax == null) {
+    options.enableExperimentalComponentSyntax = true;
+  }
+
+  if (options.enableExperimentalFlowMatchSyntax == null) {
+    options.enableExperimentalFlowMatchSyntax = true;
+  }
+
+  if (options.enableExperimentalFlowRecordSyntax == null) {
+    options.enableExperimentalFlowRecordSyntax = true;
+  }
+
+  options.enableRecords = options.enableExperimentalFlowRecordSyntax;
+
+  if (options.enableEnums == null) {
+    options.enableEnums = true;
+  }
+
+  if (options.enableExperimentalDecorators == null) {
+    options.enableExperimentalDecorators = true;
+  }
+
+  options.tokens = options.tokens === true;
+  options.allowReturnOutsideFunction = options.allowReturnOutsideFunction === true;
+  return options;
+}
+
+function parse(code, opts) {
+  var _options$transformOpt, _options$transformOpt2;
+
+  const options = getOptions(opts);
+
+  if (options.flow === 'all') {
+    options.enableTypes = true;
+  } else {
+    options.enableTypesPragmaDetection = true;
+  }
+
+  const estreeAST = FlowParser.parse(code, options);
+
+  if (options.babel !== true) {
+    return estreeAST;
+  }
+
+  const loweredESTreeAST = [(_options$transformOpt = options.transformOptions) != null && (_options$transformOpt2 = _options$transformOpt.TransformEnumSyntax) != null && _options$transformOpt2.enable ? TransformEnumSyntax.transformProgram : null, TransformMatchSyntax.transformProgram, TransformComponentSyntax.transformProgram, TransformRecordSyntax.transformProgram, StripFlowTypesForBabel.transformProgram].reduce((ast, transform) => {
+    var _transform;
+
+    return (_transform = transform == null ? void 0 : transform(ast, options)) != null ? _transform : ast;
+  }, estreeAST);
+  return TransformESTreeToBabel.transformProgram(loweredESTreeAST, options);
+}
+
+const Transforms = {
+  transformEnumSyntax: TransformEnumSyntax.transformProgram,
+  transformMatchSyntax: TransformMatchSyntax.transformProgram,
+  transformComponentSyntax: TransformComponentSyntax.transformProgram,
+  transformRecordSyntax: TransformRecordSyntax.transformProgram,
+  stripFlowTypesForBabel: StripFlowTypesForBabel.transformProgram,
+  stripFlowTypes: StripFlowTypes.transformProgram
+};
+exports.Transforms = Transforms;