flow-parser 0.320.0 → 0.322.0

package/{oxidized → dist}/transform/print/comments/prettier/language-js/comments.js

@@ -12,7 +12,6 @@ const {
   getNextNonSpaceNonCommentCharacter,
   isNonEmptyArray
 } = require('../common/util.js');
-
 const {
   isBlockComment,
   getFunctionParameters,
@@ -23,36 +22,29 @@ const {
   isMemberExpression,
   isObjectProperty
 } = require('./utils.js');
-
 const {
   locStart,
   locEnd
 } = require('./loc.js');
-
 function handleOwnLineComment(context) {
   return [handleIgnoreComments, handleLastFunctionArgComments, handleMemberExpressionComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleImportSpecifierComments, handleForComments, handleUnionTypeComments, handleMatchOrPatternComments, handleOnlyComments, handleImportDeclarationComments, handleAssignmentPatternComments, handleMethodNameComments, handleLabeledStatementComments].some(fn => fn(context));
 }
-
 function handleEndOfLineComment(context) {
   return [handleClosureTypeCastComments, handleLastFunctionArgComments, handleConditionalExpressionComments, handleImportSpecifierComments, handleIfStatementComments, handleWhileComments, handleTryStatementComments, handleClassComments, handleLabeledStatementComments, handleCallExpressionComments, handlePropertyComments, handleOnlyComments, handleTypeAliasComments, handleVariableDeclaratorComments].some(fn => fn(context));
 }
-
 function handleRemainingComment(context) {
   return [handleIgnoreComments, handleIfStatementComments, handleWhileComments, handleObjectPropertyAssignment, handleCommentInEmptyParens, handleMethodNameComments, handleOnlyComments, handleCommentAfterArrowParams, handleFunctionNameComments, handleTSMappedTypeComments, handleBreakAndContinueStatementComments, handleTSFunctionTrailingComments].some(fn => fn(context));
 }
-
 function addBlockStatementFirstComment(node, comment) {
   const firstNonEmptyNode = (node.body || node.properties).find(({
     type
   }) => type !== 'EmptyStatement');
-
   if (firstNonEmptyNode) {
     addLeadingComment(firstNonEmptyNode, comment);
   } else {
     addDanglingComment(node, comment);
   }
 }
-
 function addBlockOrNotComment(node, comment) {
   if (node.type === 'BlockStatement') {
     addBlockStatementFirstComment(node, comment);
@@ -60,7 +52,6 @@ function addBlockOrNotComment(node, comment) {
     addLeadingComment(node, comment);
   }
 }
-
 function handleClosureTypeCastComments({
   comment,
   followingNode
@@ -69,10 +60,8 @@ function handleClosureTypeCastComments({
     addLeadingComment(followingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleIfStatementComments({
   comment,
   precedingNode,
@@ -83,42 +72,33 @@ function handleIfStatementComments({
   if (!enclosingNode || enclosingNode.type !== 'IfStatement' || !followingNode) {
     return false;
   }
-
   const nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
-
   if (nextCharacter === ')') {
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   if (precedingNode === enclosingNode.consequent && followingNode === enclosingNode.alternate) {
     if (precedingNode.type === 'BlockStatement') {
       addTrailingComment(precedingNode, comment);
     } else {
       addDanglingComment(enclosingNode, comment);
     }
-
     return true;
   }
-
   if (followingNode.type === 'BlockStatement') {
     addBlockStatementFirstComment(followingNode, comment);
     return true;
   }
-
   if (followingNode.type === 'IfStatement') {
     addBlockOrNotComment(followingNode.consequent, comment);
     return true;
   }
-
   if (enclosingNode.consequent === followingNode) {
     addLeadingComment(followingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleWhileComments({
   comment,
   precedingNode,
@@ -129,27 +109,21 @@ function handleWhileComments({
   if (!enclosingNode || enclosingNode.type !== 'WhileStatement' || !followingNode) {
     return false;
   }
-
   const nextCharacter = getNextNonSpaceNonCommentCharacter(text, comment, locEnd);
-
   if (nextCharacter === ')') {
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   if (followingNode.type === 'BlockStatement') {
     addBlockStatementFirstComment(followingNode, comment);
     return true;
   }
-
   if (enclosingNode.body === followingNode) {
     addLeadingComment(followingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleTryStatementComments({
   comment,
   precedingNode,
@@ -159,30 +133,24 @@ function handleTryStatementComments({
   if (!enclosingNode || enclosingNode.type !== 'TryStatement' && enclosingNode.type !== 'CatchClause' || !followingNode) {
     return false;
   }
-
   if (enclosingNode.type === 'CatchClause' && precedingNode) {
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   if (followingNode.type === 'BlockStatement') {
     addBlockStatementFirstComment(followingNode, comment);
     return true;
   }
-
   if (followingNode.type === 'TryStatement') {
     addBlockOrNotComment(followingNode.finalizer, comment);
     return true;
   }
-
   if (followingNode.type === 'CatchClause') {
     addBlockOrNotComment(followingNode.body, comment);
     return true;
   }
-
   return false;
 }
-
 function handleMemberExpressionComments({
   comment,
   enclosingNode,
@@ -192,10 +160,8 @@ function handleMemberExpressionComments({
     addLeadingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleConditionalExpressionComments({
   comment,
   precedingNode,
@@ -204,15 +170,12 @@ function handleConditionalExpressionComments({
   text
 }) {
   const isSameLineAsPrecedingNode = precedingNode && !hasNewlineInRange(text, locEnd(precedingNode), locStart(comment));
-
   if ((!precedingNode || !isSameLineAsPrecedingNode) && enclosingNode && (enclosingNode.type === 'ConditionalExpression' || enclosingNode.type === 'TSConditionalType') && followingNode) {
     addLeadingComment(followingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleObjectPropertyAssignment({
   comment,
   precedingNode,
@@ -222,10 +185,8 @@ function handleObjectPropertyAssignment({
     addTrailingComment(enclosingNode.value.left, comment);
     return true;
   }
-
   return false;
 }
-
 function handleClassComments({
   comment,
   precedingNode,
@@ -237,12 +198,10 @@ function handleClassComments({
       addTrailingComment(getLast(enclosingNode.decorators), comment);
       return true;
     }
-
     if (enclosingNode.body && followingNode === enclosingNode.body) {
       addBlockStatementFirstComment(enclosingNode.body, comment);
       return true;
     }
-
     if (followingNode) {
       for (const prop of ['implements', 'extends', 'mixins']) {
         if (enclosingNode[prop] && followingNode === enclosingNode[prop][0]) {
@@ -251,16 +210,13 @@ function handleClassComments({
           } else {
             addDanglingComment(enclosingNode, comment, prop);
           }
-
           return true;
         }
       }
     }
   }
-
   return false;
 }
-
 function handleMethodNameComments({
   comment,
   precedingNode,
@@ -271,15 +227,12 @@ function handleMethodNameComments({
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   if (precedingNode && enclosingNode && precedingNode.type === 'Decorator' && (enclosingNode.type === 'ClassMethod' || enclosingNode.type === 'ClassProperty' || enclosingNode.type === 'PropertyDefinition' || enclosingNode.type === 'TSAbstractPropertyDefinition' || enclosingNode.type === 'TSAbstractMethodDefinition' || enclosingNode.type === 'TSDeclareMethod' || enclosingNode.type === 'MethodDefinition')) {
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleFunctionNameComments({
   comment,
   precedingNode,
@@ -289,15 +242,12 @@ function handleFunctionNameComments({
   if (getNextNonSpaceNonCommentCharacter(text, comment, locEnd) !== '(') {
     return false;
   }
-
   if (precedingNode && enclosingNode && (enclosingNode.type === 'FunctionDeclaration' || enclosingNode.type === 'FunctionExpression' || enclosingNode.type === 'ClassMethod' || enclosingNode.type === 'MethodDefinition' || enclosingNode.type === 'ObjectMethod')) {
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleCommentAfterArrowParams({
   comment,
   enclosingNode,
@@ -306,17 +256,13 @@ function handleCommentAfterArrowParams({
   if (!(enclosingNode && enclosingNode.type === 'ArrowFunctionExpression')) {
     return false;
   }
-
   const index = getNextNonSpaceNonCommentCharacterIndex(text, comment, locEnd);
-
   if (index !== false && text.slice(index, index + 2) === '=>') {
     addDanglingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleCommentInEmptyParens({
   comment,
   enclosingNode,
@@ -325,20 +271,16 @@ function handleCommentInEmptyParens({
   if (getNextNonSpaceNonCommentCharacter(text, comment, locEnd) !== ')') {
     return false;
   }
-
   if (enclosingNode && (isRealFunctionLikeNode(enclosingNode) && getFunctionParameters(enclosingNode).length === 0 || isCallLikeExpression(enclosingNode) && getCallArguments(enclosingNode).length === 0)) {
     addDanglingComment(enclosingNode, comment);
     return true;
   }
-
   if (enclosingNode && (enclosingNode.type === 'MethodDefinition' || enclosingNode.type === 'TSAbstractMethodDefinition') && getFunctionParameters(enclosingNode.value).length === 0) {
     addDanglingComment(enclosingNode.value, comment);
     return true;
   }
-
   return false;
 }
-
 function handleLastFunctionArgComments({
   comment,
   precedingNode,
@@ -350,33 +292,26 @@ function handleLastFunctionArgComments({
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   if (precedingNode && (precedingNode.type === 'Identifier' || precedingNode.type === 'AssignmentPattern') && enclosingNode && isRealFunctionLikeNode(enclosingNode) && getNextNonSpaceNonCommentCharacter(text, comment, locEnd) === ')') {
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   if (enclosingNode && enclosingNode.type === 'FunctionDeclaration' && followingNode && followingNode.type === 'BlockStatement') {
     const functionParamRightParenIndex = (() => {
       const parameters = getFunctionParameters(enclosingNode);
-
       if (parameters.length > 0) {
         return getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(getLast(parameters)));
       }
-
       const functionParamLeftParenIndex = getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, locEnd(enclosingNode.id));
       return functionParamLeftParenIndex !== false && getNextNonSpaceNonCommentCharacterIndexWithStartIndex(text, functionParamLeftParenIndex + 1);
     })();
-
     if (locStart(comment) > functionParamRightParenIndex) {
       addBlockStatementFirstComment(followingNode, comment);
       return true;
     }
   }
-
   return false;
 }
-
 function handleImportSpecifierComments({
   comment,
   enclosingNode
@@ -385,10 +320,8 @@ function handleImportSpecifierComments({
     addLeadingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleLabeledStatementComments({
   comment,
   enclosingNode
@@ -397,10 +330,8 @@ function handleLabeledStatementComments({
     addLeadingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleBreakAndContinueStatementComments({
   comment,
   enclosingNode
@@ -409,10 +340,8 @@ function handleBreakAndContinueStatementComments({
     addTrailingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleCallExpressionComments({
   comment,
   precedingNode,
@@ -422,10 +351,8 @@ function handleCallExpressionComments({
     addLeadingComment(enclosingNode.arguments[0], comment);
     return true;
   }
-
   return false;
 }
-
 function handleUnionTypeComments({
   comment,
   precedingNode,
@@ -437,23 +364,18 @@ function handleUnionTypeComments({
       followingNode.prettierIgnore = true;
       comment.unignore = true;
     }
-
     if (precedingNode) {
       addTrailingComment(precedingNode, comment);
       return true;
     }
-
     return false;
   }
-
   if (followingNode && (followingNode.type === 'UnionTypeAnnotation' || followingNode.type === 'TSUnionType') && isPrettierIgnoreComment(comment)) {
     followingNode.types[0].prettierIgnore = true;
     comment.unignore = true;
   }
-
   return false;
 }
-
 function handleMatchOrPatternComments({
   comment,
   precedingNode,
@@ -465,23 +387,18 @@ function handleMatchOrPatternComments({
       followingNode.prettierIgnore = true;
       comment.unignore = true;
     }
-
     if (precedingNode) {
       addTrailingComment(precedingNode, comment);
       return true;
     }
-
     return false;
   }
-
   if (followingNode && followingNode.type === 'MatchOrPattern' && isPrettierIgnoreComment(comment)) {
     followingNode.types[0].prettierIgnore = true;
     comment.unignore = true;
   }
-
   return false;
 }
-
 function handlePropertyComments({
   comment,
   enclosingNode
@@ -490,10 +407,8 @@ function handlePropertyComments({
     addLeadingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleOnlyComments({
   comment,
   enclosingNode,
@@ -507,28 +422,22 @@ function handleOnlyComments({
     } else {
       addLeadingComment(ast, comment);
     }
-
     return true;
   }
-
   if (enclosingNode && enclosingNode.type === 'Program' && enclosingNode.body.length === 0 && !isNonEmptyArray(enclosingNode.directives)) {
     if (isLastComment) {
       addDanglingComment(enclosingNode, comment);
     } else {
       addLeadingComment(enclosingNode, comment);
     }
-
     return true;
   }
-
   if (followingNode && followingNode.type === 'Program' && followingNode.body.length === 0 && enclosingNode && enclosingNode.type === 'ModuleExpression') {
     addDanglingComment(followingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleForComments({
   comment,
   enclosingNode
@@ -537,10 +446,8 @@ function handleForComments({
     addLeadingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleImportDeclarationComments({
   comment,
   precedingNode,
@@ -551,10 +458,8 @@ function handleImportDeclarationComments({
     addTrailingComment(precedingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleAssignmentPatternComments({
   comment,
   enclosingNode
@@ -563,10 +468,8 @@ function handleAssignmentPatternComments({
     addLeadingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleTypeAliasComments({
   comment,
   enclosingNode
@@ -575,10 +478,8 @@ function handleTypeAliasComments({
     addLeadingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleVariableDeclaratorComments({
   comment,
   enclosingNode,
@@ -588,10 +489,8 @@ function handleVariableDeclaratorComments({
     addLeadingComment(followingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleTSFunctionTrailingComments({
   comment,
   enclosingNode,
@@ -602,10 +501,8 @@ function handleTSFunctionTrailingComments({
     addTrailingComment(enclosingNode, comment);
     return true;
   }
-
   return false;
 }
-
 function handleIgnoreComments({
   comment,
   enclosingNode,
@@ -617,7 +514,6 @@ function handleIgnoreComments({
     return true;
   }
 }
-
 function handleTSMappedTypeComments({
   comment,
   precedingNode,
@@ -627,34 +523,27 @@ function handleTSMappedTypeComments({
   if (!enclosingNode || enclosingNode.type !== 'TSMappedType') {
     return false;
   }
-
   if (followingNode && followingNode.type === 'TSTypeParameter' && followingNode.name) {
     addLeadingComment(followingNode.name, comment);
     return true;
   }
-
   if (precedingNode && precedingNode.type === 'TSTypeParameter' && precedingNode.constraint) {
     addTrailingComment(precedingNode.constraint, comment);
     return true;
   }
-
   return false;
 }
-
 function isRealFunctionLikeNode(node) {
   return node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression' || node.type === 'FunctionDeclaration' || node.type === 'ObjectMethod' || node.type === 'ClassMethod' || node.type === 'TSDeclareFunction' || node.type === 'TSCallSignatureDeclaration' || node.type === 'TSConstructSignatureDeclaration' || node.type === 'TSMethodSignature' || node.type === 'TSConstructorType' || node.type === 'TSFunctionType' || node.type === 'TSDeclareMethod';
 }
-
 function getCommentChildNodes(node, options) {
   if ((options.parser === 'typescript' || options.parser === 'flow' || options.parser === 'espree' || options.parser === 'meriyah' || options.parser === '__babel_estree') && node.type === 'MethodDefinition' && node.value && node.value.type === 'FunctionExpression' && getFunctionParameters(node.value).length === 0 && !node.value.returnType && !isNonEmptyArray(node.value.typeParameters) && node.value.body) {
     return [...(node.decorators || []), node.key, node.value.body];
   }
 }
-
 function isTypeCastComment(comment) {
   return isBlockComment(comment) && comment.value[0] === '*' && /@type\b/.test(comment.value);
 }
-
 module.exports = {
   handleOwnLineComment,
   handleEndOfLineComment,

package/{oxidized/oxidized-src → dist}/transform/print/comments/prettier/language-js/loc.js

@@ -3,27 +3,21 @@
 const {
   isNonEmptyArray
 } = require('../common/util.js');
-
 function locStart(node, opts) {
   const {
     ignoreDecorators
   } = opts || {};
-
   if (!ignoreDecorators) {
     const decorators = node.declaration && node.declaration.decorators || node.decorators;
-
     if (isNonEmptyArray(decorators)) {
       return locStart(decorators[0]);
     }
   }
-
   return node.range ? node.range[0] : node.start;
 }
-
 function locEnd(node) {
   return node.range ? node.range[1] : node.end;
 }
-
 module.exports = {
   locStart,
   locEnd

package/{oxidized/oxidized-src → dist}/transform/print/comments/prettier/language-js/printer-estree.js

@@ -1,16 +1,13 @@
 'use strict';
 
 const handleComments = require('./comments.js');
-
 const {
   isBlockComment,
   isLineComment
 } = require('./utils.js');
-
 function canAttachComment(node) {
   return node.type && !isBlockComment(node) && !isLineComment(node) && node.type !== 'EmptyStatement' && node.type !== 'TemplateElement' && node.type !== 'Import' && node.type !== 'TSEmptyBodyFunctionExpression';
 }
-
 module.exports = {
   canAttachComment,
   handleComments: {

package/{oxidized/oxidized-src → dist}/transform/print/comments/prettier/language-js/utils.js

@@ -3,79 +3,59 @@
 function isBlockComment(comment) {
   return comment.type === 'Block' || comment.type === 'CommentBlock' || comment.type === 'MultiLine';
 }
-
 function isLineComment(comment) {
   return comment.type === 'Line' || comment.type === 'CommentLine' || comment.type === 'SingleLine' || comment.type === 'HashbangComment' || comment.type === 'HTMLOpen' || comment.type === 'HTMLClose';
 }
-
 function isCallExpression(node) {
   return node && (node.type === 'CallExpression' || node.type === 'OptionalCallExpression');
 }
-
 function isMemberExpression(node) {
   return node && (node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression');
 }
-
 const functionParametersCache = new WeakMap();
-
 function getFunctionParameters(node) {
   if (functionParametersCache.has(node)) {
     return functionParametersCache.get(node);
   }
-
   const parameters = [];
-
   if (node.this) {
     parameters.push(node.this);
   }
-
   if (Array.isArray(node.parameters)) {
     parameters.push(...node.parameters);
   } else if (Array.isArray(node.params)) {
     parameters.push(...node.params);
   }
-
   if (node.rest) {
     parameters.push(node.rest);
   }
-
   functionParametersCache.set(node, parameters);
   return parameters;
 }
-
 const callArgumentsCache = new WeakMap();
-
 function getCallArguments(node) {
   if (callArgumentsCache.has(node)) {
     return callArgumentsCache.get(node);
   }
-
   let args = node.arguments;
-
   if (node.type === 'ImportExpression') {
     args = [node.source];
-
     if (node.attributes) {
       args.push(node.attributes);
     }
   }
-
   callArgumentsCache.set(node, args);
   return args;
 }
-
 function isPrettierIgnoreComment(comment) {
   return comment.value.trim() === 'prettier-ignore' && !comment.unignore;
 }
-
 function isCallLikeExpression(node) {
   return isCallExpression(node) || node.type === 'NewExpression' || node.type === 'ImportExpression';
 }
-
 function isObjectProperty(node) {
   return node && (node.type === 'ObjectProperty' || node.type === 'Property' && !node.method && node.kind === 'init');
 }
-
 module.exports = {
   getFunctionParameters,
   getCallArguments,