eslint-plugin-jsdoc 39.3.3 → 39.3.6

package/dist/utils/hasReturnValue.js

@@ -0,0 +1,364 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.hasValueOrExecutorHasNonEmptyResolveValue = exports.hasReturnValue = void 0;
+
+/* eslint-disable jsdoc/no-undefined-types */
+
+/**
+ * Checks if a node is a promise but has no resolve value or an empty value.
+ * An `undefined` resolve does not count.
+ *
+ * @param {object} node
+ * @returns {boolean}
+ */
+const isNewPromiseExpression = node => {
+  return node && node.type === 'NewExpression' && node.callee.type === 'Identifier' && node.callee.name === 'Promise';
+};
+
+const isVoidPromise = node => {
+  var _node$typeParameters, _node$typeParameters$, _node$typeParameters$2;
+
+  return (node === null || node === void 0 ? void 0 : (_node$typeParameters = node.typeParameters) === null || _node$typeParameters === void 0 ? void 0 : (_node$typeParameters$ = _node$typeParameters.params) === null || _node$typeParameters$ === void 0 ? void 0 : (_node$typeParameters$2 = _node$typeParameters$[0]) === null || _node$typeParameters$2 === void 0 ? void 0 : _node$typeParameters$2.type) === 'TSVoidKeyword';
+};
+/**
+ * @callback PromiseFilter
+ * @param {object} node
+ * @returns {boolean}
+ */
+
+/**
+ * Checks if a node has a return statement. Void return does not count.
+ *
+ * @param {object} node
+ * @param {PromiseFilter} promFilter
+ * @returns {boolean|Node}
+ */
+// eslint-disable-next-line complexity
+
+
+const hasReturnValue = (node, promFilter) => {
+  var _node$returnType, _node$returnType$type;
+
+  if (!node) {
+    return false;
+  }
+
+  switch (node.type) {
+    case 'TSFunctionType':
+    case 'TSMethodSignature':
+      return !['TSVoidKeyword', 'TSUndefinedKeyword'].includes(node === null || node === void 0 ? void 0 : (_node$returnType = node.returnType) === null || _node$returnType === void 0 ? void 0 : (_node$returnType$type = _node$returnType.typeAnnotation) === null || _node$returnType$type === void 0 ? void 0 : _node$returnType$type.type);
+
+    case 'MethodDefinition':
+      return hasReturnValue(node.value, promFilter);
+
+    case 'FunctionExpression':
+    case 'FunctionDeclaration':
+    case 'ArrowFunctionExpression':
+      {
+        return node.expression && (!isNewPromiseExpression(node.body) || !isVoidPromise(node.body)) || hasReturnValue(node.body, promFilter);
+      }
+
+    case 'BlockStatement':
+      {
+        return node.body.some(bodyNode => {
+          return bodyNode.type !== 'FunctionDeclaration' && hasReturnValue(bodyNode, promFilter);
+        });
+      }
+
+    case 'LabeledStatement':
+    case 'WhileStatement':
+    case 'DoWhileStatement':
+    case 'ForStatement':
+    case 'ForInStatement':
+    case 'ForOfStatement':
+    case 'WithStatement':
+      {
+        return hasReturnValue(node.body, promFilter);
+      }
+
+    case 'IfStatement':
+      {
+        return hasReturnValue(node.consequent, promFilter) || hasReturnValue(node.alternate, promFilter);
+      }
+
+    case 'TryStatement':
+      {
+        return hasReturnValue(node.block, promFilter) || hasReturnValue(node.handler && node.handler.body, promFilter) || hasReturnValue(node.finalizer, promFilter);
+      }
+
+    case 'SwitchStatement':
+      {
+        return node.cases.some(someCase => {
+          return someCase.consequent.some(nde => {
+            return hasReturnValue(nde, promFilter);
+          });
+        });
+      }
+
+    case 'ReturnStatement':
+      {
+        // void return does not count.
+        if (node.argument === null) {
+          return false;
+        }
+
+        if (promFilter && isNewPromiseExpression(node.argument)) {
+          // Let caller decide how to filter, but this is, at the least,
+          //   a return of sorts and truthy
+          return promFilter(node.argument);
+        }
+
+        return true;
+      }
+
+    default:
+      {
+        return false;
+      }
+  }
+};
+/**
+ * Avoids further checking child nodes if a nested function shadows the
+ * resolver, but otherwise, if name is used (by call or passed in as an
+ * argument to another function), will be considered as non-empty.
+ *
+ * This could check for redeclaration of the resolver, but as such is
+ * unlikely, we avoid the performance cost of checking everywhere for
+ * (re)declarations or assignments.
+ *
+ * @param {AST} node
+ * @param {string} resolverName
+ * @returns {boolean}
+ */
+// eslint-disable-next-line complexity
+
+
+exports.hasReturnValue = hasReturnValue;
+
+const hasNonEmptyResolverCall = (node, resolverName) => {
+  if (!node) {
+    return false;
+  } // Arrow function without block
+
+
+  switch (node.type) {
+    // istanbul ignore next -- In Babel?
+    case 'OptionalCallExpression':
+    case 'CallExpression':
+      return node.callee.name === resolverName && ( // Implicit or explicit undefined
+      node.arguments.length > 1 || node.arguments[0] !== undefined) || node.arguments.some(nde => {
+        // Being passed in to another function (which might invoke it)
+        return nde.type === 'Identifier' && nde.name === resolverName || // Handle nested items
+        hasNonEmptyResolverCall(nde, resolverName);
+      });
+
+    case 'ChainExpression':
+    case 'Decorator':
+    case 'ExpressionStatement':
+      return hasNonEmptyResolverCall(node.expression, resolverName);
+
+    case 'ClassBody':
+    case 'BlockStatement':
+      return node.body.some(bodyNode => {
+        return hasNonEmptyResolverCall(bodyNode, resolverName);
+      });
+
+    case 'FunctionExpression':
+    case 'FunctionDeclaration':
+    case 'ArrowFunctionExpression':
+      {
+        var _node$params$;
+
+        // Shadowing
+        if (((_node$params$ = node.params[0]) === null || _node$params$ === void 0 ? void 0 : _node$params$.name) === resolverName) {
+          return false;
+        }
+
+        return hasNonEmptyResolverCall(node.body, resolverName);
+      }
+
+    case 'LabeledStatement':
+    case 'WhileStatement':
+    case 'DoWhileStatement':
+    case 'ForStatement':
+    case 'ForInStatement':
+    case 'ForOfStatement':
+    case 'WithStatement':
+      {
+        return hasNonEmptyResolverCall(node.body, resolverName);
+      }
+
+    case 'ConditionalExpression':
+    case 'IfStatement':
+      {
+        return hasNonEmptyResolverCall(node.test, resolverName) || hasNonEmptyResolverCall(node.consequent, resolverName) || hasNonEmptyResolverCall(node.alternate, resolverName);
+      }
+
+    case 'TryStatement':
+      {
+        return hasNonEmptyResolverCall(node.block, resolverName) || hasNonEmptyResolverCall(node.handler && node.handler.body, resolverName) || hasNonEmptyResolverCall(node.finalizer, resolverName);
+      }
+
+    case 'SwitchStatement':
+      {
+        return node.cases.some(someCase => {
+          return someCase.consequent.some(nde => {
+            return hasNonEmptyResolverCall(nde, resolverName);
+          });
+        });
+      }
+
+    case 'ArrayPattern':
+    case 'ArrayExpression':
+      return node.elements.some(element => {
+        return hasNonEmptyResolverCall(element, resolverName);
+      });
+
+    case 'AssignmentPattern':
+      return hasNonEmptyResolverCall(node.right, resolverName);
+
+    case 'AssignmentExpression':
+    case 'BinaryExpression':
+    case 'LogicalExpression':
+      {
+        return hasNonEmptyResolverCall(node.left, resolverName) || hasNonEmptyResolverCall(node.right, resolverName);
+      }
+    // Comma
+
+    case 'SequenceExpression':
+    case 'TemplateLiteral':
+      return node.expressions.some(subExpression => {
+        return hasNonEmptyResolverCall(subExpression, resolverName);
+      });
+
+    case 'ObjectPattern':
+    case 'ObjectExpression':
+      return node.properties.some(property => {
+        return hasNonEmptyResolverCall(property, resolverName);
+      });
+    // istanbul ignore next -- In Babel?
+
+    case 'ClassMethod':
+    case 'MethodDefinition':
+      return node.decorators && node.decorators.some(decorator => {
+        return hasNonEmptyResolverCall(decorator, resolverName);
+      }) || node.computed && hasNonEmptyResolverCall(node.key, resolverName) || hasNonEmptyResolverCall(node.value, resolverName);
+    // istanbul ignore next -- In Babel?
+
+    case 'ObjectProperty':
+    /* eslint-disable no-fallthrough */
+    // istanbul ignore next -- In Babel?
+
+    case 'PropertyDefinition': // istanbul ignore next -- In Babel?
+
+    case 'ClassProperty':
+    /* eslint-enable no-fallthrough */
+
+    case 'Property':
+      return node.computed && hasNonEmptyResolverCall(node.key, resolverName) || hasNonEmptyResolverCall(node.value, resolverName);
+    // istanbul ignore next -- In Babel?
+
+    case 'ObjectMethod':
+      // istanbul ignore next -- In Babel?
+      return node.computed && hasNonEmptyResolverCall(node.key, resolverName) || node.arguments.some(nde => {
+        return hasNonEmptyResolverCall(nde, resolverName);
+      });
+
+    case 'ClassExpression':
+    case 'ClassDeclaration':
+      return hasNonEmptyResolverCall(node.body, resolverName);
+
+    case 'AwaitExpression':
+    case 'SpreadElement':
+    case 'UnaryExpression':
+    case 'YieldExpression':
+      return hasNonEmptyResolverCall(node.argument, resolverName);
+
+    case 'VariableDeclaration':
+      {
+        return node.declarations.some(nde => {
+          return hasNonEmptyResolverCall(nde, resolverName);
+        });
+      }
+
+    case 'VariableDeclarator':
+      {
+        return hasNonEmptyResolverCall(node.id, resolverName) || hasNonEmptyResolverCall(node.init, resolverName);
+      }
+
+    case 'TaggedTemplateExpression':
+      return hasNonEmptyResolverCall(node.quasi, resolverName);
+    // ?.
+    // istanbul ignore next -- In Babel?
+
+    case 'OptionalMemberExpression':
+    case 'MemberExpression':
+      return hasNonEmptyResolverCall(node.object, resolverName) || hasNonEmptyResolverCall(node.property, resolverName);
+    // istanbul ignore next -- In Babel?
+
+    case 'Import':
+    case 'ImportExpression':
+      return hasNonEmptyResolverCall(node.source, resolverName);
+
+    case 'ReturnStatement':
+      {
+        if (node.argument === null) {
+          return false;
+        }
+
+        return hasNonEmptyResolverCall(node.argument, resolverName);
+      }
+
+    /*
+    // Shouldn't need to parse literals/literal components, etc.
+     case 'Identifier':
+    case 'TemplateElement':
+    case 'Super':
+    // Exports not relevant in this context
+    */
+
+    default:
+      return false;
+  }
+};
+/**
+ * Checks if a Promise executor has no resolve value or an empty value.
+ * An `undefined` resolve does not count.
+ *
+ * @param {object} node
+ * @param {boolean} anyPromiseAsReturn
+ * @returns {boolean}
+ */
+
+
+const hasValueOrExecutorHasNonEmptyResolveValue = (node, anyPromiseAsReturn) => {
+  return hasReturnValue(node, prom => {
+    if (anyPromiseAsReturn) {
+      return true;
+    }
+
+    if (isVoidPromise(prom)) {
+      return false;
+    }
+
+    const [{
+      params,
+      body
+    } = {}] = prom.arguments;
+
+    if (!(params !== null && params !== void 0 && params.length)) {
+      return false;
+    }
+
+    const [{
+      name: resolverName
+    }] = params;
+    return hasNonEmptyResolverCall(body, resolverName);
+  });
+};
+
+exports.hasValueOrExecutorHasNonEmptyResolveValue = hasValueOrExecutorHasNonEmptyResolveValue;
+//# sourceMappingURL=hasReturnValue.js.map

package/dist/utils/hasReturnValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hasReturnValue.js","names":["isNewPromiseExpression","node","type","callee","name","isVoidPromise","typeParameters","params","hasReturnValue","promFilter","includes","returnType","typeAnnotation","value","expression","body","some","bodyNode","consequent","alternate","block","handler","finalizer","cases","someCase","nde","argument","hasNonEmptyResolverCall","resolverName","arguments","length","undefined","test","elements","element","right","left","expressions","subExpression","properties","property","decorators","decorator","computed","key","declarations","id","init","quasi","object","source","hasValueOrExecutorHasNonEmptyResolveValue","anyPromiseAsReturn","prom"],"sources":["../../src/utils/hasReturnValue.js"],"sourcesContent":["/* eslint-disable jsdoc/no-undefined-types */\n/**\n * Checks if a node is a promise but has no resolve value or an empty value.\n * An `undefined` resolve does not count.\n *\n * @param {object} node\n * @returns {boolean}\n */\nconst isNewPromiseExpression = (node) => {\n  return node && node.type === 'NewExpression' && node.callee.type === 'Identifier' &&\n    node.callee.name === 'Promise';\n};\n\nconst isVoidPromise = (node) => {\n  return node?.typeParameters?.params?.[0]?.type === 'TSVoidKeyword';\n};\n\n/**\n * @callback PromiseFilter\n * @param {object} node\n * @returns {boolean}\n */\n\n/**\n * Checks if a node has a return statement. Void return does not count.\n *\n * @param {object} node\n * @param {PromiseFilter} promFilter\n * @returns {boolean|Node}\n */\n// eslint-disable-next-line complexity\nconst hasReturnValue = (node, promFilter) => {\n  if (!node) {\n    return false;\n  }\n\n  switch (node.type) {\n  case 'TSFunctionType':\n  case 'TSMethodSignature':\n    return ![\n      'TSVoidKeyword',\n      'TSUndefinedKeyword',\n    ].includes(node?.returnType?.typeAnnotation?.type);\n  case 'MethodDefinition':\n    return hasReturnValue(node.value, promFilter);\n  case 'FunctionExpression':\n  case 'FunctionDeclaration':\n  case 'ArrowFunctionExpression': {\n    return node.expression && (!isNewPromiseExpression(node.body) || !isVoidPromise(node.body)) ||\n      hasReturnValue(node.body, promFilter);\n  }\n\n  case 'BlockStatement': {\n    return node.body.some((bodyNode) => {\n      return bodyNode.type !== 'FunctionDeclaration' && hasReturnValue(bodyNode, promFilter);\n    });\n  }\n\n  case 'LabeledStatement':\n  case 'WhileStatement':\n  case 'DoWhileStatement':\n  case 'ForStatement':\n  case 'ForInStatement':\n  case 'ForOfStatement':\n  case 'WithStatement': {\n    return hasReturnValue(node.body, promFilter);\n  }\n\n  case 'IfStatement': {\n    return hasReturnValue(node.consequent, promFilter) || hasReturnValue(node.alternate, promFilter);\n  }\n\n  case 'TryStatement': {\n    return hasReturnValue(node.block, promFilter) ||\n      hasReturnValue(node.handler && node.handler.body, promFilter) ||\n      hasReturnValue(node.finalizer, promFilter);\n  }\n\n  case 'SwitchStatement': {\n    return node.cases.some(\n      (someCase) => {\n        return someCase.consequent.some((nde) => {\n          return hasReturnValue(nde, promFilter);\n        });\n      },\n    );\n  }\n\n  case 'ReturnStatement': {\n    // void return does not count.\n    if (node.argument === null) {\n      return false;\n    }\n\n    if (promFilter && isNewPromiseExpression(node.argument)) {\n      // Let caller decide how to filter, but this is, at the least,\n      //   a return of sorts and truthy\n      return promFilter(node.argument);\n    }\n\n    return true;\n  }\n\n  default: {\n    return false;\n  }\n  }\n};\n\n/**\n * Avoids further checking child nodes if a nested function shadows the\n * resolver, but otherwise, if name is used (by call or passed in as an\n * argument to another function), will be considered as non-empty.\n *\n * This could check for redeclaration of the resolver, but as such is\n * unlikely, we avoid the performance cost of checking everywhere for\n * (re)declarations or assignments.\n *\n * @param {AST} node\n * @param {string} resolverName\n * @returns {boolean}\n */\n// eslint-disable-next-line complexity\nconst hasNonEmptyResolverCall = (node, resolverName) => {\n  if (!node) {\n    return false;\n  }\n\n  // Arrow function without block\n  switch (node.type) {\n  // istanbul ignore next -- In Babel?\n  case 'OptionalCallExpression':\n  case 'CallExpression':\n    return node.callee.name === resolverName && (\n\n      // Implicit or explicit undefined\n      node.arguments.length > 1 || node.arguments[0] !== undefined\n    ) ||\n      node.arguments.some((nde) => {\n        // Being passed in to another function (which might invoke it)\n        return nde.type === 'Identifier' && nde.name === resolverName ||\n\n          // Handle nested items\n          hasNonEmptyResolverCall(nde, resolverName);\n      });\n  case 'ChainExpression':\n  case 'Decorator':\n  case 'ExpressionStatement':\n    return hasNonEmptyResolverCall(node.expression, resolverName);\n  case 'ClassBody':\n  case 'BlockStatement':\n    return node.body.some((bodyNode) => {\n      return hasNonEmptyResolverCall(bodyNode, resolverName);\n    });\n  case 'FunctionExpression':\n  case 'FunctionDeclaration':\n  case 'ArrowFunctionExpression': {\n    // Shadowing\n    if (node.params[0]?.name === resolverName) {\n      return false;\n    }\n\n    return hasNonEmptyResolverCall(node.body, resolverName);\n  }\n\n  case 'LabeledStatement':\n  case 'WhileStatement':\n  case 'DoWhileStatement':\n  case 'ForStatement':\n  case 'ForInStatement':\n  case 'ForOfStatement':\n  case 'WithStatement': {\n    return hasNonEmptyResolverCall(node.body, resolverName);\n  }\n\n  case 'ConditionalExpression':\n  case 'IfStatement': {\n    return hasNonEmptyResolverCall(node.test, resolverName) ||\n      hasNonEmptyResolverCall(node.consequent, resolverName) ||\n      hasNonEmptyResolverCall(node.alternate, resolverName);\n  }\n\n  case 'TryStatement': {\n    return hasNonEmptyResolverCall(node.block, resolverName) ||\n      hasNonEmptyResolverCall(node.handler && node.handler.body, resolverName) ||\n      hasNonEmptyResolverCall(node.finalizer, resolverName);\n  }\n\n  case 'SwitchStatement': {\n    return node.cases.some(\n      (someCase) => {\n        return someCase.consequent.some((nde) => {\n          return hasNonEmptyResolverCall(nde, resolverName);\n        });\n      },\n    );\n  }\n\n  case 'ArrayPattern':\n  case 'ArrayExpression':\n    return node.elements.some((element) => {\n      return hasNonEmptyResolverCall(element, resolverName);\n    });\n\n  case 'AssignmentPattern':\n    return hasNonEmptyResolverCall(node.right, resolverName);\n\n  case 'AssignmentExpression':\n  case 'BinaryExpression':\n  case 'LogicalExpression': {\n    return hasNonEmptyResolverCall(node.left, resolverName) ||\n      hasNonEmptyResolverCall(node.right, resolverName);\n  }\n\n  // Comma\n  case 'SequenceExpression':\n  case 'TemplateLiteral':\n    return node.expressions.some((subExpression) => {\n      return hasNonEmptyResolverCall(subExpression, resolverName);\n    });\n\n  case 'ObjectPattern':\n  case 'ObjectExpression':\n    return node.properties.some((property) => {\n      return hasNonEmptyResolverCall(property, resolverName);\n    });\n  // istanbul ignore next -- In Babel?\n  case 'ClassMethod':\n  case 'MethodDefinition':\n    return node.decorators && node.decorators.some((decorator) => {\n      return hasNonEmptyResolverCall(decorator, resolverName);\n    }) ||\n      node.computed && hasNonEmptyResolverCall(node.key, resolverName) ||\n      hasNonEmptyResolverCall(node.value, resolverName);\n\n  // istanbul ignore next -- In Babel?\n  case 'ObjectProperty':\n  /* eslint-disable no-fallthrough */\n  // istanbul ignore next -- In Babel?\n  case 'PropertyDefinition':\n  // istanbul ignore next -- In Babel?\n  case 'ClassProperty':\n  /* eslint-enable no-fallthrough */\n  case 'Property':\n    return node.computed && hasNonEmptyResolverCall(node.key, resolverName) ||\n      hasNonEmptyResolverCall(node.value, resolverName);\n  // istanbul ignore next -- In Babel?\n  case 'ObjectMethod':\n    // istanbul ignore next -- In Babel?\n    return node.computed && hasNonEmptyResolverCall(node.key, resolverName) ||\n      node.arguments.some((nde) => {\n        return hasNonEmptyResolverCall(nde, resolverName);\n      });\n\n  case 'ClassExpression':\n  case 'ClassDeclaration':\n    return hasNonEmptyResolverCall(node.body, resolverName);\n\n  case 'AwaitExpression':\n  case 'SpreadElement':\n  case 'UnaryExpression':\n  case 'YieldExpression':\n    return hasNonEmptyResolverCall(node.argument, resolverName);\n\n  case 'VariableDeclaration': {\n    return node.declarations.some((nde) => {\n      return hasNonEmptyResolverCall(nde, resolverName);\n    });\n  }\n\n  case 'VariableDeclarator': {\n    return hasNonEmptyResolverCall(node.id, resolverName) ||\n      hasNonEmptyResolverCall(node.init, resolverName);\n  }\n\n  case 'TaggedTemplateExpression':\n    return hasNonEmptyResolverCall(node.quasi, resolverName);\n\n  // ?.\n  // istanbul ignore next -- In Babel?\n  case 'OptionalMemberExpression':\n  case 'MemberExpression':\n    return hasNonEmptyResolverCall(node.object, resolverName) ||\n      hasNonEmptyResolverCall(node.property, resolverName);\n\n  // istanbul ignore next -- In Babel?\n  case 'Import':\n  case 'ImportExpression':\n    return hasNonEmptyResolverCall(node.source, resolverName);\n\n  case 'ReturnStatement': {\n    if (node.argument === null) {\n      return false;\n    }\n\n    return hasNonEmptyResolverCall(node.argument, resolverName);\n  }\n\n  /*\n  // Shouldn't need to parse literals/literal components, etc.\n\n  case 'Identifier':\n  case 'TemplateElement':\n  case 'Super':\n  // Exports not relevant in this context\n  */\n  default:\n    return false;\n  }\n};\n\n/**\n * Checks if a Promise executor has no resolve value or an empty value.\n * An `undefined` resolve does not count.\n *\n * @param {object} node\n * @param {boolean} anyPromiseAsReturn\n * @returns {boolean}\n */\nconst hasValueOrExecutorHasNonEmptyResolveValue = (node, anyPromiseAsReturn) => {\n  return hasReturnValue(node, (prom) => {\n    if (anyPromiseAsReturn) {\n      return true;\n    }\n\n    if (isVoidPromise(prom)) {\n      return false;\n    }\n\n    const [\n      {\n        params,\n        body,\n      } = {},\n    ] = prom.arguments;\n\n    if (!params?.length) {\n      return false;\n    }\n\n    const [\n      {\n        name: resolverName,\n      },\n    ] = params;\n\n    return hasNonEmptyResolverCall(body, resolverName);\n  });\n};\n\nexport {\n  hasReturnValue,\n  hasValueOrExecutorHasNonEmptyResolveValue,\n};\n"],"mappings":"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"}

package/package.json

@@ -117,5 +117,5 @@
     "test-cov": "cross-env TIMING=1 nyc --reporter text npm run test-no-cov",
     "test-index": "npm run test-no-cov -- test/rules/index.js"
   },
-  "version": "39.3.3"
+  "version": "39.3.6"
 }

package/CONTRIBUTING.md

@@ -1,100 +0,0 @@
-# CONTRIBUTING to eslint-plugin-jsdoc
-
-## Testing changes locally
-
-You might try a TDD approach and add tests within the `test` directory,
-to try different configs you may find it easier to try out changes in
-a separate local directory.
-
-You can run [`npm link`](https://docs.npmjs.com/cli/link) for this purpose,
-pointing from your project to this project. For example, while in your project
-root and with `eslint-plugin-jsdoc` as a sibling, run:
-
-```shell
-npm link ../eslint-plugin-jsdoc
-```
-
-## Building the project
-
-After running `npm install` to get the latest dependencies and devDependencies,
-you can run the following command to update the `dist` files, with `dist/index.js`
-being the `main` entry point from `package.json`:
-
-```shell
-npm run build
-```
-
-## Coding standards
-
-The project follows ESLint rules from [`canonical`](https://www.npmjs.com/package/eslint-config-canonical)
-and testing follows its subconfig, `canonical/mocha`. You can run
-`npm run lint` to check the linting if your IDE is not already indicating
-items needing fixing.
-
-## Documentation building
-
-To make changes that are reflected in the README, you will need to
-modify files within the `.README` directory. `.README/README.md` contains the
-main README skeleton and details on the project, its global `settings`, etc.,
-while the documentation for specific rules (that will be pulled into the
-README) ought to be modified within the relevant file within `.README/rules`.
-Once these files are modified, you can run `npm run create-readme` to have
-these files integrated into the main `/README.md`. While you should include
-the built file in your PR, you will not want to make manual changes
-directly to this file, as they will be overwritten.
-
-## Testing
-
-Tests are expected. Each rule file should be in CamelCase (despite the rule names themselves being hyphenated) and should be added within `test/assertions` and then imported/required by
-`test/rules/index.js`.
-
-Each rule file should be an ESM default export of an object that has `valid` and `invalid` array properties containing the tests. Tests of each type should be provided.
-
-`parserOptions` will be `ecmaVersion: 6` by default, but tests can override `parserOptions`
-with their own.
-
-See ESLint's [RuleTester](https://eslint.org/docs/developer-guide/nodejs-api#ruletester)
-for more on the allowable properties (e.g., `code`, `errors` (for invalid rules),
-`options`, `settings`, etc.).
-
-Note that besides `npm test` there is `npm run test-cov`, which shows more
-detailed coverage information. Coverage should be maintained at 100%, and
-if there are a few guards in place for future use, the code block in question
-can be ignored by being preceded by `/* istanbul ignore next */` (including
-for warnings where the block is never passed over (i.e., the block is always
-entered)). If you want to test without coverage at all, you can use
-`npm run test-no-cov`. To only test rules rather than other files, you
-can use `npm run test-index`.
-
-To test specific rules, you can supply a comma-separated list with the `--rule`
-flag passed to `test-index`, e.g., for `check-examples` and `require-example`:
-
-`npm run test-index --rule=check-examples,require-example`.
-
-You can further limit this by providing `--invalid` and/or `--valid` flags
-with a comma-separated list of 0-based indexes that you wish to include (also
-accepts negative offsets from the end, e.g., `-1` for the last item). For
-example, to check the first and third invalid tests of `check-examples`
-along with the second valid test, you can run:
-
-`npm run --rule=check-examples --invalid=0,2 --valid=1 test-index`.
-
-## Requirements for PRs
-
-PRs should be mergeable, [rebasing](https://git-scm.com/book/en/v2/Git-Branching-Rebasing)
-first against the latest `master`.
-
-The number of commits will ideally be limited unless extra commits
-can better show a progression of features.
-
-Commit messages should be worded clearly and the reason for any PR made clear
-by linking to an issue or giving a full description of what it achieves.
-
-## Merging
-
-We use [semantic-release](https://github.com/semantic-release/semantic-release)
-for preparing releases, so the commit messages (or at least the merge that
-brings them into `master`) must follow the
-[AngularJS commit guidelines](https://github.com/angular/angular.js/blob/master/DEVELOPERS.md#-git-commit-guidelines) with a special format such as `feat: describe new feature`
-for releases to occur and for the described items to be added
-to the release notes.