hermes-transform 0.8.0 → 0.9.0

package/dist/transform/TransformContext.js.flow

@@ -18,8 +18,9 @@ import type {
   Statement,
   TypeAnnotationType,
 } from 'hermes-estree';
-import type {DetachedNode} from '../detachedNode';
+import type {DetachedNode, MaybeDetachedNode} from '../detachedNode';
 import type {TransformCloneSignatures} from '../generated/TransformCloneSignatures';
+import type {TransformModifySignatures} from '../generated/TransformModifySignatures';
 import type {TransformReplaceSignatures} from '../generated/TransformReplaceSignatures';
 import type {TraversalContext} from '../traverse/traverse';
 import type {AddCommentsMutation} from './mutations/AddComments';
@@ -29,9 +30,12 @@ import type {RemoveCommentMutation} from './mutations/RemoveComment';
 import type {RemoveNodeMutation} from './mutations/RemoveNode';
 import type {RemoveStatementMutation} from './mutations/RemoveStatement';
 import type {ReplaceNodeMutation} from './mutations/ReplaceNode';
-import type {ReplaceStatementWithManyMutation} from './mutations/ReplaceStatementWithMany';
+import type {
+  ReplaceStatementWithManyMutation,
+  ReplaceStatementWithManyMutationNodes,
+} from './mutations/ReplaceStatementWithMany';
 
-import {deepCloneNode, shallowCloneNode} from '../detachedNode';
+import {asDetachedNode, deepCloneNode, shallowCloneNode} from '../detachedNode';
 import {
   CommentPlacement,
   getCommentsForNode,
@@ -103,6 +107,8 @@ type TransformCloneAPIs = $ReadOnly<{
   shallowCloneArray: {
     <T: ESNode>(node: $ReadOnlyArray<T>): $ReadOnlyArray<DetachedNode<T>>,
     <T: ESNode>(node: ?$ReadOnlyArray<T>): ?$ReadOnlyArray<DetachedNode<T>>,
+    <T: ESNode>(node: $ReadOnlyArray<?T>): $ReadOnlyArray<DetachedNode<?T>>,
+    <T: ESNode>(node: ?$ReadOnlyArray<?T>): ?$ReadOnlyArray<DetachedNode<?T>>,
   },
 
   /**
@@ -148,14 +154,14 @@ type TransformCommentAPIs = $ReadOnly<{
    */
   cloneCommentsTo: (
     target: ESNode,
-    destination: ESNode | DetachedNode<ESNode>,
+    destination: MaybeDetachedNode<ESNode>,
   ) => void,
 
   /**
    * Add comments on the line before a specified node.
    */
   addLeadingComments: (
-    node: ESNode | DetachedNode<ESNode>,
+    node: MaybeDetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
@@ -163,7 +169,7 @@ type TransformCommentAPIs = $ReadOnly<{
    * Add comments inline before a specified node.
    */
   addLeadingInlineComments: (
-    node: ESNode | DetachedNode<ESNode>,
+    node: MaybeDetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
@@ -171,7 +177,7 @@ type TransformCommentAPIs = $ReadOnly<{
    * Add comments on the line after a specified node.
    */
   addTrailingComments: (
-    node: ESNode | DetachedNode<ESNode>,
+    node: MaybeDetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
@@ -179,7 +185,7 @@ type TransformCommentAPIs = $ReadOnly<{
    * Add comments inline after a specified node.
    */
   addTrailingInlineComments: (
-    node: ESNode | DetachedNode<ESNode>,
+    node: MaybeDetachedNode<ESNode>,
     comments: SingleOrArray<Comment>,
   ) => void,
 
@@ -197,7 +203,7 @@ type TransformInsertAPIs = $ReadOnly<{
   insertAfterStatement: (
     target: InsertStatementMutation['target'],
     nodeToInsert: SingleOrArray<
-      DetachedNode<InsertStatementMutation['target']>,
+      MaybeDetachedNode<InsertStatementMutation['target']>,
     >,
   ) => void,
 
@@ -208,11 +214,19 @@ type TransformInsertAPIs = $ReadOnly<{
   insertBeforeStatement: (
     target: InsertStatementMutation['target'],
     nodeToInsert: SingleOrArray<
-      DetachedNode<InsertStatementMutation['target']>,
+      MaybeDetachedNode<InsertStatementMutation['target']>,
     >,
   ) => void,
 }>;
 
+type TransformModifyAPIs = $ReadOnly<{
+  /**
+   * Modifies a given node in place.
+   * This is equivalent to doing a replace with a shallow clone with overrides.
+   */
+  modifyNodeInPlace: TransformModifySignatures,
+}>;
+
 type TransformRemoveAPIs = $ReadOnly<{
   /**
    * Removes a given node from the AST.
@@ -236,37 +250,37 @@ type TransformReplaceAPIs = $ReadOnly<{
     // Expressions may be replaced with other expressions
     (
       target: Expression,
-      nodeToReplaceWith: DetachedNode<Expression>,
+      nodeToReplaceWith: MaybeDetachedNode<Expression>,
       options?: ReplaceNodeOptions,
     ): void,
     // Module declarations may be replaced with statements or other module declarations
     (
       target: ModuleDeclaration,
-      nodeToReplaceWith: DetachedNode<ModuleDeclaration | Statement>,
+      nodeToReplaceWith: MaybeDetachedNode<ModuleDeclaration | Statement>,
       options?: ReplaceNodeOptions,
     ): void,
     // Statement maybe be replaced with statements or module declarations
     (
       target: Statement,
-      nodeToReplaceWith: DetachedNode<ModuleDeclaration | Statement>,
+      nodeToReplaceWith: MaybeDetachedNode<ModuleDeclaration | Statement>,
       options?: ReplaceNodeOptions,
     ): void,
     // Types maybe be replaced with other types
     (
       target: TypeAnnotationType,
-      nodeToReplaceWith: DetachedNode<TypeAnnotationType>,
+      nodeToReplaceWith: MaybeDetachedNode<TypeAnnotationType>,
       options?: ReplaceNodeOptions,
     ): void,
     // Class members may be replaced with other class members
     (
       target: ClassMember,
-      nodeToReplaceWith: DetachedNode<ClassMember>,
+      nodeToReplaceWith: MaybeDetachedNode<ClassMember>,
       options?: ReplaceNodeOptions,
     ): void,
     // Function params amy be replace with other function params
     (
       target: FunctionParameter,
-      nodeToReplaceWith: DetachedNode<FunctionParameter>,
+      nodeToReplaceWith: MaybeDetachedNode<FunctionParameter>,
       options?: ReplaceNodeOptions,
     ): void,
   } & TransformReplaceSignatures, // allow like-for-like replacements as well
@@ -277,7 +291,9 @@ type TransformReplaceAPIs = $ReadOnly<{
    */
   replaceStatementWithMany: (
     target: ReplaceStatementWithManyMutation['target'],
-    nodesToReplaceWith: ReplaceStatementWithManyMutation['nodesToReplaceWith'],
+    nodesToReplaceWith: $ReadOnlyArray<
+      MaybeDetachedNode<ReplaceStatementWithManyMutationNodes>,
+    >,
     options?: {
       /**
        * Moves the comments from the target node to the first node in the array.
@@ -296,6 +312,7 @@ export type TransformContextAdditions = $ReadOnly<{
   ...TransformCommentAPIs,
   ...TransformCloneAPIs,
   ...TransformInsertAPIs,
+  ...TransformModifyAPIs,
   ...TransformRemoveAPIs,
   ...TransformReplaceAPIs,
 }>;
@@ -321,14 +338,15 @@ export function getTransformContext(): TransformContextAdditions {
         return null;
       }
 
-      return shallowCloneNode(node);
+      return shallowCloneNode(node, {});
     }: TransformCloneAPIs['shallowCloneNode']),
 
-    // $FlowExpectedError[incompatible-exact]
     shallowCloneNodeWithOverrides: ((
       node: ?ESNode,
-      newProps?: $ReadOnly<{...}>,
-    ): ?DetachedNode<ESNode> => {
+      newProps?: $ReadOnly<{...}> = {},
+    ): // $FlowExpectedError[incompatible-cast]
+    // $FlowExpectedError[prop-missing]
+    ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
@@ -337,14 +355,20 @@ export function getTransformContext(): TransformContextAdditions {
     }: TransformCloneAPIs['shallowCloneNodeWithOverrides']),
 
     shallowCloneArray: (<T: ESNode>(
-      nodes: ?$ReadOnlyArray<T>,
+      nodes: ?$ReadOnlyArray<?T>,
     ): // $FlowExpectedError[incompatible-cast]
-    ?$ReadOnlyArray<DetachedNode<ESNode>> => {
+    ?$ReadOnlyArray<DetachedNode<?ESNode>> => {
       if (nodes == null) {
         return null;
       }
 
-      return nodes.map(node => shallowCloneNode<T>(node));
+      return nodes.map(node => {
+        if (node == null) {
+          // $FlowExpectedError[incompatible-call]
+          return node;
+        }
+        return shallowCloneNode<T>(node, {});
+      });
     }: TransformCloneAPIs['shallowCloneArray']),
 
     deepCloneNode: ((
@@ -355,14 +379,15 @@ export function getTransformContext(): TransformContextAdditions {
         return null;
       }
 
-      return deepCloneNode(node);
+      return deepCloneNode(node, {});
     }: TransformCloneAPIs['deepCloneNode']),
 
-    // $FlowExpectedError[incompatible-exact]
     deepCloneNodeWithOverrides: ((
       node: ?ESNode,
-      newProps?: $ReadOnly<{...}>,
-    ): ?DetachedNode<ESNode> => {
+      newProps?: $ReadOnly<{...}> = {},
+    ): // $FlowExpectedError[incompatible-cast]
+    // $FlowExpectedError[prop-missing]
+    ?DetachedNode<ESNode> => {
       if (node == null) {
         return null;
       }
@@ -444,13 +469,25 @@ export function getTransformContext(): TransformContextAdditions {
   const insertAPIs: TransformInsertAPIs = {
     insertAfterStatement: ((target, nodesToInsert): void => {
       pushMutation(
-        createInsertStatementMutation('after', target, toArray(nodesToInsert)),
+        createInsertStatementMutation(
+          'after',
+          target,
+          toArray(nodesToInsert).map(n =>
+            asDetachedNode(n, {useDeepClone: true}),
+          ),
+        ),
       );
     }: TransformInsertAPIs['insertBeforeStatement']),
 
     insertBeforeStatement: ((target, nodesToInsert): void => {
       pushMutation(
-        createInsertStatementMutation('before', target, toArray(nodesToInsert)),
+        createInsertStatementMutation(
+          'before',
+          target,
+          toArray(nodesToInsert).map(n =>
+            asDetachedNode(n, {useDeepClone: true}),
+          ),
+        ),
       );
     }: TransformInsertAPIs['insertBeforeStatement']),
   };
@@ -466,11 +503,15 @@ export function getTransformContext(): TransformContextAdditions {
   const replaceAPIs: TransformReplaceAPIs = {
     replaceNode: ((
       target: ESNode,
-      nodeToReplaceWith: DetachedNode<ESNode>,
+      nodeToReplaceWith: MaybeDetachedNode<ESNode>,
       options?: ReplaceNodeOptions,
     ): void => {
       pushMutation(
-        createReplaceNodeMutation(target, nodeToReplaceWith, options),
+        createReplaceNodeMutation(
+          target,
+          asDetachedNode(nodeToReplaceWith),
+          options,
+        ),
       );
     }: TransformReplaceAPIs['replaceNode']),
 
@@ -482,12 +523,27 @@ export function getTransformContext(): TransformContextAdditions {
       pushMutation(
         createReplaceStatementWithManyMutation(
           target,
-          nodesToReplaceWith,
+          nodesToReplaceWith.map(n => asDetachedNode(n)),
           options,
         ),
       );
     }: TransformReplaceAPIs['replaceStatementWithMany']),
   };
+  const modifyAPIs: TransformModifyAPIs = {
+    modifyNodeInPlace: ((
+      node: ?ESNode,
+      newProps?: $ReadOnly<{...}> = {},
+      options?: ReplaceNodeOptions,
+    ): void => {
+      if (node == null) {
+        return;
+      }
+
+      const cloned = shallowCloneNode(node, newProps, {preserveLocation: true});
+      // $FlowExpectedError[incompatible-call]
+      replaceAPIs.replaceNode(node, cloned, options);
+    }: TransformModifyAPIs['modifyNodeInPlace']),
+  };
 
   return {
     mutations,
@@ -500,6 +556,7 @@ export function getTransformContext(): TransformContextAdditions {
     ...cloneAPIs,
     ...commentAPIs,
     ...insertAPIs,
+    ...modifyAPIs,
     ...removeAPIs,
     ...replaceAPIs,
   };

package/dist/transform/comments/comments.js

@@ -11,6 +11,8 @@ exports.attachComments = attachComments;
 exports.cloneComment = cloneComment;
 exports.cloneCommentWithMarkers = cloneCommentWithMarkers;
 exports.getCommentsForNode = getCommentsForNode;
+exports.getLeadingCommentsForNode = getLeadingCommentsForNode;
+exports.getTrailingCommentsForNode = getTrailingCommentsForNode;
 exports.isLeadingComment = isLeadingComment;
 exports.isTrailingComment = isTrailingComment;
 exports.moveCommentsToNewNode = moveCommentsToNewNode;
@@ -62,13 +64,21 @@ function setCommentsOnNode(node, comments) {
   node.comments = comments;
 }
 
-function addCommentsToNode(node, comments) {
+function addCommentsToNode(node, comments, side = 'trailing') {
   var _node$comments;
 
-  // $FlowExpectedError - this property is secretly added by prettier.
-  node.comments = (_node$comments = node.comments) != null ? _node$comments : []; // $FlowExpectedError
-
-  node.comments.push(...comments);
+  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
+  // $FlowExpectedError[cannot-write]
+  // $FlowExpectedError[incompatible-use]
+  node.comments = (_node$comments = node.comments) != null ? _node$comments : [];
+
+  if (side === 'leading') {
+    // $FlowExpectedError[incompatible-cast]
+    node.comments.unshift(...comments);
+  } else {
+    // $FlowExpectedError[incompatible-cast]
+    node.comments.push(...comments);
+  }
 }
 
 function getCommentsForNode(node) {
@@ -88,6 +98,14 @@ function isTrailingComment(comment) {
   return comment.trailing === true;
 }
 
+function getLeadingCommentsForNode(node) {
+  return getCommentsForNode(node).filter(isLeadingComment);
+}
+
+function getTrailingCommentsForNode(node) {
+  return getCommentsForNode(node).filter(isTrailingComment);
+}
+
 function addComment(node, comment, placement) {
   switch (placement) {
     case CommentPlacement.LEADING_OWN_LINE:

package/dist/transform/comments/comments.js.flow

@@ -65,11 +65,19 @@ export function setCommentsOnNode(
 export function addCommentsToNode(
   node: ESNode | DetachedNode<ESNode>,
   comments: $ReadOnlyArray<Comment>,
+  side?: 'leading' | 'trailing' = 'trailing',
 ): void {
-  // $FlowExpectedError - this property is secretly added by prettier.
+  // $FlowExpectedError[prop-missing] - this property is secretly added by prettier.
+  // $FlowExpectedError[cannot-write]
+  // $FlowExpectedError[incompatible-use]
   node.comments = node.comments ?? [];
-  // $FlowExpectedError
-  (node.comments: Array<Comment>).push(...comments);
+  if (side === 'leading') {
+    // $FlowExpectedError[incompatible-cast]
+    (node.comments: Array<Comment>).unshift(...comments);
+  } else {
+    // $FlowExpectedError[incompatible-cast]
+    (node.comments: Array<Comment>).push(...comments);
+  }
 }
 
 export function getCommentsForNode(
@@ -88,6 +96,18 @@ export function isTrailingComment(comment: Comment): boolean {
   return comment.trailing === true;
 }
 
+export function getLeadingCommentsForNode(
+  node: ESNode | DetachedNode<ESNode>,
+): $ReadOnlyArray<Comment> {
+  return getCommentsForNode(node).filter(isLeadingComment);
+}
+
+export function getTrailingCommentsForNode(
+  node: ESNode | DetachedNode<ESNode>,
+): $ReadOnlyArray<Comment> {
+  return getCommentsForNode(node).filter(isTrailingComment);
+}
+
 export function addComment(
   node: ESNode | DetachedNode<ESNode>,
   comment: Comment,

package/dist/transform/getTransformedAST.js

@@ -122,6 +122,21 @@ function getTransformedAST(code, visitors) {
     if (mutationRoot) {
       (0, _detachedNode.updateAllParentPointers)(mutationRoot);
     }
+  } // if the very first node in the program is replaced, it will take the docblock with it
+  // this is bad as it means we'll lose `@format`, ``, licence, etc.
+  // so this hack just makes sure that we keep the docblock
+  // note that we do this **BEFORE** the comment mutations in case someone intentionally
+  // wants to remove the docblock comment for some weird reason
+
+
+  if (ast.docblock != null && ast.body.length > 0) {
+    const firstNode = ast.body[0];
+    const docblockComment = ast.docblock.comment;
+    const leadingComments = (0, _comments.getLeadingCommentsForNode)(firstNode);
+
+    if (!leadingComments.includes(docblockComment)) {
+      (0, _comments.addCommentsToNode)(firstNode, [docblockComment], 'leading');
+    }
   } // remove the comments
   // this is done at the end because it requires a complete traversal of the AST
   // so that we can find relevant node's attachment array

package/dist/transform/getTransformedAST.js.flow

@@ -19,7 +19,11 @@ import {updateAllParentPointers} from '../detachedNode';
 import {traverseWithContext} from '../traverse/traverse';
 import {MutationContext} from './MutationContext';
 import {getTransformContext} from './TransformContext';
-import {attachComments} from './comments/comments';
+import {
+  addCommentsToNode,
+  attachComments,
+  getLeadingCommentsForNode,
+} from './comments/comments';
 import {performAddCommentsMutation} from './mutations/AddComments';
 import {performCloneCommentsToMutation} from './mutations/CloneCommentsTo';
 import {performInsertStatementMutation} from './mutations/InsertStatement';
@@ -120,6 +124,20 @@ export function getTransformedAST(
     }
   }
 
+  // if the very first node in the program is replaced, it will take the docblock with it
+  // this is bad as it means we'll lose `@format`, `@flow`, licence, etc.
+  // so this hack just makes sure that we keep the docblock
+  // note that we do this **BEFORE** the comment mutations in case someone intentionally
+  // wants to remove the docblock comment for some weird reason
+  if (ast.docblock != null && ast.body.length > 0) {
+    const firstNode = ast.body[0];
+    const docblockComment = ast.docblock.comment;
+    const leadingComments = getLeadingCommentsForNode(firstNode);
+    if (!leadingComments.includes(docblockComment)) {
+      addCommentsToNode(firstNode, [docblockComment], 'leading');
+    }
+  }
+
   // remove the comments
   // this is done at the end because it requires a complete traversal of the AST
   // so that we can find relevant node's attachment array

package/dist/transform/mutations/InsertStatement.js

@@ -86,5 +86,6 @@ function performInsertStatementMutation(mutationContext, mutation) {
     parent: insertionParent.parent
   });
   insertionParent.parent[insertionParent.key] = blockStatement;
+  statementToWrap.parent = blockStatement;
   return insertionParent.parent;
 }

package/dist/transform/mutations/InsertStatement.js.flow

@@ -113,6 +113,7 @@ export function performInsertStatementMutation(
 
   (insertionParent.parent: interface {[string]: mixed})[insertionParent.key] =
     blockStatement;
+  statementToWrap.parent = blockStatement;
 
   return insertionParent.parent;
 }

package/dist/transform/mutations/ReplaceNode.js

@@ -12,6 +12,8 @@ var _comments = require("../comments/comments");
 
 var _Errors = require("../Errors");
 
+var _detachedNode = require("../../detachedNode");
+
 var _getVisitorKeys = require("../../getVisitorKeys");
 
 /**
@@ -71,7 +73,10 @@ function getParentKey(target) {
       }
     } else if (Array.isArray(parent[key])) {
       for (let i = 0; i < parent[key].length; i += 1) {
-        if (parent[key][i] === target) {
+        const current = parent[key][i];
+        const originalNode = (0, _detachedNode.getOriginalNode)(current);
+
+        if (current === target || originalNode === target) {
           return {
             type: 'array',
             parent,
@@ -84,5 +89,5 @@ function getParentKey(target) {
   } // this shouldn't happen ever
 
 
-  throw new _Errors.InvalidReplacementError(`Expected to find the ${target.type} as a direct child of the ${target.type}.`);
+  throw new _Errors.InvalidReplacementError(`Expected to find the ${target.type} as a direct child of the ${parent.type}.`);
 }

package/dist/transform/mutations/ReplaceNode.js.flow

@@ -15,6 +15,7 @@ import type {DetachedNode} from '../../detachedNode';
 import {replaceInArray} from './utils/arrayUtils';
 import {moveCommentsToNewNode} from '../comments/comments';
 import {InvalidReplacementError} from '../Errors';
+import {getOriginalNode} from '../../detachedNode';
 import {getVisitorKeys, isNode} from '../../getVisitorKeys';
 
 export type ReplaceNodeMutation = $ReadOnly<{
@@ -99,7 +100,9 @@ function getParentKey(target: ESNode): $ReadOnly<
       }
     } else if (Array.isArray(parent[key])) {
       for (let i = 0; i < parent[key].length; i += 1) {
-        if (parent[key][i] === target) {
+        const current = parent[key][i];
+        const originalNode = getOriginalNode(current);
+        if (current === target || originalNode === target) {
           return {type: 'array', parent, key, targetIndex: i};
         }
       }
@@ -108,6 +111,6 @@ function getParentKey(target: ESNode): $ReadOnly<
 
   // this shouldn't happen ever
   throw new InvalidReplacementError(
-    `Expected to find the ${target.type} as a direct child of the ${target.type}.`,
+    `Expected to find the ${target.type} as a direct child of the ${parent.type}.`,
   );
 }

package/dist/transform/mutations/ReplaceStatementWithMany.js.flow

@@ -19,11 +19,14 @@ import {moveCommentsToNewNode} from '../comments/comments';
 import {InvalidReplacementError} from '../Errors';
 import * as t from '../../generated/node-types';
 
+export type ReplaceStatementWithManyMutationNodes =
+  | ModuleDeclaration
+  | Statement;
 export type ReplaceStatementWithManyMutation = $ReadOnly<{
   type: 'replaceStatementWithMany',
-  target: ModuleDeclaration | Statement,
+  target: ReplaceStatementWithManyMutationNodes,
   nodesToReplaceWith: $ReadOnlyArray<
-    DetachedNode<ModuleDeclaration | Statement>,
+    DetachedNode<ReplaceStatementWithManyMutationNodes>,
   >,
   keepComments: boolean,
 }>;

package/dist/traverse/NodeEventGenerator.js.flow

@@ -34,7 +34,7 @@ type ParsedSelector = $ReadOnly<{
 
 const ESQUERY_OPTIONS: ESQueryOptions = Object.freeze({
   visitorKeys: VisitorKeys,
-  fallback: node => {
+  fallback: (node: ESNode) => {
     throw new Error(`No visitor keys found for node type "${node.type}".`);
   },
 });

package/dist/traverse/traverse.js.flow

@@ -140,7 +140,7 @@ export function traverseWithContext<T = TraversalContextBase>(
       scopeManager.getDeclaredVariables(node),
 
     getBinding: (name: string) => {
-      let currentScope = getScope();
+      let currentScope: null | Scope = getScope();
 
       while (currentScope != null) {
         for (const variable of currentScope.variables) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hermes-transform",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Tools built on top of Hermes-ESTree to enable codebase transformation",
   "main": "dist/index.js",
   "license": "MIT",
@@ -12,13 +12,17 @@
     "@babel/code-frame": "^7.16.0",
     "esquery": "^1.4.0",
     "flow-enums-runtime": "^0.0.6",
-    "hermes-eslint": "0.8.0",
-    "hermes-estree": "0.8.0"
+    "hermes-eslint": "0.9.0",
+    "hermes-estree": "0.9.0"
   },
   "peerDependencies": {
     "prettier": "^2.4.1"
   },
   "files": [
-    "dist"
+    "dist",
+    "LICENCE",
+    "ESLINT_LICENCE",
+    "PRETTIER_LICENCE",
+    "README.md"
   ]
 }