@cookshack/eslint-config 2.0.5 → 3.0.0

package/dist/index.js

@@ -1,18 +1,17 @@
 import globals from 'globals';
 
-let rules, languageOptions, plugins;
-
-let printBuffer;
+let varIds, nextVarId, printBuffer;
 
 printBuffer = [];
+varIds = new Map();
+nextVarId = 0;
 
 function print
 (...args) {
-  //console.log(args.join(' '))
   printBuffer.push(args.join(' '));
 }
 
-function trace
+function trace$1
 (...args) {
 }
 
@@ -32,7 +31,7 @@ function getNarrowestScope
 
   common = null;
   for (let ref of variable.references) {
-    if (variable.defs.some(def => def.name === ref.identifier))
+    if (variable.defs.some(def => def.name == ref.identifier))
       continue
     if (ref.from)
       if (common)
@@ -102,15 +101,15 @@ function getConditionalContext
   prevNode = ref.identifier;
   node = ref.identifier.parent;
   while (node) {
-    if (node === scopeBlock)
+    if (node == scopeBlock)
       break
-    if (node.type === 'IfStatement')
-      if (prevNode === node.test || nodeContains(node.test, prevNode))
+    if (node.type == 'IfStatement')
+      if (prevNode == node.test || nodeContains(node.test, prevNode))
         prevNode = node;
       else
         return 'B'
     else if ([ 'WhileStatement', 'DoWhileStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement', 'SwitchStatement' ].includes(node.type))
-      if (prevNode === node.test || nodeContains(node.test, prevNode))
+      if (prevNode == node.test || nodeContains(node.test, prevNode))
         prevNode = node;
       else
         return 'B'
@@ -122,9 +121,9 @@ function getConditionalContext
 }
 
 function nodeContains(node, target) {
-  if (node === target)
+  if (node == target)
     return true
-  if (node && typeof node === 'object')
+  if (node && typeof node == 'object')
     for (let key in node)
       if (nodeHas(node[key], target))
         return true
@@ -132,7 +131,7 @@ function nodeContains(node, target) {
 }
 
 function nodeHas(value, target) {
-  if (value === target)
+  if (value == target)
     return true
   if (Array.isArray(value))
     return value.some(v => nodeContains(v, target))
@@ -146,15 +145,15 @@ function isConditionalRef
   node = ref.identifier.parent;
 
   while (node) {
-    if (node === narrowestScope.block)
+    if (node == narrowestScope.block)
       break
-    if (node.type === 'BlockStatement') {
+    if (node.type == 'BlockStatement') {
       let parent;
 
       parent = node.parent;
-      if (parent?.type === 'IfStatement' && (parent.consequent === node || parent.alternate === node))
+      if (parent?.type == 'IfStatement' && (parent.consequent == node || parent.alternate == node))
         return true
-      if ([ 'WhileStatement', 'DoWhileStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement' ].includes(parent?.type) && parent.body === node)
+      if ([ 'WhileStatement', 'DoWhileStatement', 'ForStatement', 'ForInStatement', 'ForOfStatement' ].includes(parent?.type) && parent.body == node)
         return true
     }
     node = node.parent;
@@ -186,14 +185,11 @@ function mayBeReadBeforeAnyWrite
     let item;
 
     if (isReadRef(ref))
-      // a possible read
       return 1
 
     item = ref.cookshackNarrowestScopeItem;
     if (item.ctx == 'B' || isConditionalRef(ref, narrowestScope))
-      // a conditional write
       continue
-    // A guaranteed write before any possible read.
     return 0
   }
 }
@@ -208,7 +204,22 @@ function scopeStart(scope) {
   return scope.block.range[0]
 }
 
-function buildScopeTree(scope, prefix, scopeToNode) {
+function ensureInVarIds
+(variable) {
+  if (varIds.has(variable))
+    return
+  varIds.set(variable, nextVarId++);
+}
+
+function isCompoundAssignmentOp
+(op) {
+  if (op == '=')
+    return 0
+  return 1
+}
+
+function buildScopeTree
+(scope, prefix, scopeToNode, astToTree) {
   let node, siblingNum;
 
   node = {
@@ -218,40 +229,49 @@ function buildScopeTree(scope, prefix, scopeToNode) {
     children: []
   };
   scopeToNode.set(scope, node);
+  if (scope.block && astToTree)
+    astToTree.set(scope.block, node);
 
   siblingNum = 0;
   for (let child of scope.childScopes) {
     siblingNum++;
-    node.children.push(buildScopeTree(child, prefix + '.' + siblingNum, scopeToNode));
+    node.children.push(buildScopeTree(child, prefix + '.' + siblingNum, scopeToNode, astToTree));
   }
 
   for (let variable of scope.variables) {
-    if (variable.defs.length > 0)
-      node.items.push({ type: 'LET', name: variable.name, pos: variable.defs[0].name.range[0] });
+    if (variable.defs.length > 0) {
+      ensureInVarIds(variable);
+      node.items.push({ type: 'LET', name: variable.name, pos: variable.defs[0].name.range[0], defNode: variable.defs[0].node, defType: variable.defs[0].type, identifier: variable.defs[0].name, variable, varId: varIds.get(variable) });
+    }
 
     for (let ref of variable.references) {
       let targetNode;
 
       targetNode = scopeToNode.get(ref.from);
       if (targetNode) {
-        let parent, sortPos, ctx, item;
+        let parent, sortPos, ctx, item1, item2;
 
         ctx = getConditionalContext(ref);
         parent = ref.identifier.parent;
 
         if (isWriteRef(ref))
           if (ref.identifier.parent?.type == 'UpdateExpression') {
-            targetNode.items.push({ type: 'READ', name: ref.identifier.name, ctx, pos: ref.identifier.range[0] });
-            item = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] };
+            item1 = { ref, type: 'READ', name: ref.identifier.name, ctx, pos: ref.identifier.range[0] };
+            item2 = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] };
           }
           else if (ref.identifier.parent?.type == 'AssignmentExpression') {
             sortPos = parent.right.range[1] + 0.4;
-            item = { ref, type: 'WRITE', name: ref.identifier.name, ctx, pos: sortPos };
+            if (ref.identifier.parent.left == ref.identifier && isCompoundAssignmentOp(ref.identifier.parent.operator)) {
+              item1 = { ref, type: 'READ', name: ref.identifier.name, ctx, pos: ref.identifier.range[0] };
+              item2 = { ref, type: 'WRITE', name: ref.identifier.name, pos: sortPos };
+            }
+            else
+              item1 = { ref, type: 'WRITE', name: ref.identifier.name, ctx, pos: sortPos };
           }
           else if (ref.identifier.parent?.type == 'VariableDeclarator')
-            item = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] + 0.4 };
+            item1 = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] + 0.4 };
           else
-            item = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] };
+            item1 = { ref, type: 'WRITE', name: ref.identifier.name, pos: ref.identifier.range[0] };
         else {
           let declarator;
 
@@ -265,10 +285,16 @@ function buildScopeTree(scope, prefix, scopeToNode) {
             sortPos = declarator.id ? declarator.id.range[0] - 0.4 : ref.identifier.range[0];
           else
             sortPos = ref.identifier.range[0];
-          item = { ref, type: 'READ', name: ref.identifier.name, ctx, pos: sortPos };
+          item1 = { ref, type: 'READ', name: ref.identifier.name, ctx, pos: sortPos };
+        }
+        ensureInVarIds(variable);
+        item1.varId = varIds.get(variable);
+        targetNode.items.push(item1);
+        if (item2) {
+          item2.varId = varIds.get(variable);
+          targetNode.items.push(item2);
         }
-        targetNode.items.push(item);
-        ref.cookshackNarrowestScopeItem = item;
+        ref.cookshackNarrowestScopeItem = item2 || item1;
       }
     }
   }
@@ -278,7 +304,8 @@ function buildScopeTree(scope, prefix, scopeToNode) {
   return node
 }
 
-function checkScopeNode(context, treeNode, reported, scopeToNode) {
+function checkScopeNode
+(context, treeNode, reported, scopeToNode) {
   let indent;
 
   reported = reported || new Set;
@@ -289,11 +316,11 @@ function checkScopeNode(context, treeNode, reported, scopeToNode) {
 
     if (reported.has(variable))
       continue
-    if (variable.defs.length === 0)
+    if (variable.defs.length == 0)
       continue
     if ([ 'Parameter', 'FunctionName', 'ImportBinding', 'CatchClause', 'ClassName' ].includes(variable.defs[0].type))
       continue
-    if (variable.defs[0].node.parent?.parent?.type === 'ExportNamedDeclaration')
+    if (variable.defs[0].node.parent?.parent?.type == 'ExportNamedDeclaration')
       continue
 
     defNode = variable.defs[0]?.name;
@@ -302,31 +329,31 @@ function checkScopeNode(context, treeNode, reported, scopeToNode) {
 
       defScope = getDefinitionScope(variable);
       defNodePrefix = scopeToNode.get(defScope)?.prefix ?? '?';
-      trace(indent, '1 found decl scope of', variable.name + ':', defNodePrefix + ' ' + defScope.type.toUpperCase());
+      trace$1(indent, '1 found decl scope of', variable.name + ':', defNodePrefix + ' ' + defScope.type.toUpperCase());
 
       narrowestScope = getNarrowestScope(variable);
       if (narrowestScope) {
         let narrowestPrefix;
 
         narrowestPrefix = scopeToNode.get(narrowestScope)?.prefix ?? '?';
-        trace(indent, '2 found narrowest scope of', variable.name + ':', narrowestPrefix + ' ' + narrowestScope?.type.toUpperCase());
+        trace$1(indent, '2 found narrowest scope of', variable.name + ':', narrowestPrefix + ' ' + narrowestScope?.type.toUpperCase());
 
         markConditionalRefs(variable, scopeToNode, narrowestScope);
 
         if (defScope == narrowestScope)
           continue
-        trace(indent, '3', variable.name, 'could be moved to a narrower scope');
+        trace$1(indent, '3', variable.name, 'could be moved to a narrower scope');
 
         if (defScope.type == 'for') {
-          trace(indent, '4 exception:', variable.name, 'is in a for loop header');
+          trace$1(indent, '4 exception:', variable.name, 'is in a for loop header');
           continue
         }
         if (mayBeReadBeforeAnyWrite(variable, scopeToNode, narrowestScope)) {
-          trace(indent, '4 exception:', variable.name, 'mayBeReadBeforeAnyWrite');
+          trace$1(indent, '4 exception:', variable.name, 'mayBeReadBeforeAnyWrite');
           continue
         }
 
-        trace(indent, '5', variable.name, 'is too broad');
+        trace$1(indent, '5', variable.name, 'is too broad');
 
         reported.add(variable);
         context.report({
@@ -342,10 +369,11 @@ function checkScopeNode(context, treeNode, reported, scopeToNode) {
     checkScopeNode(context, child, reported, scopeToNode);
 }
 
-function printTree(node, siblingNum) {
+function printTree
+(node, siblingNum) {
   let prefix, all, indent;
 
-  prefix = siblingNum === 0 ? node.prefix : node.prefix.split('.').slice(0, -1).join('.') + '.' + siblingNum;
+  prefix = siblingNum == 0 ? node.prefix : node.prefix.split('.').slice(0, -1).join('.') + '.' + siblingNum;
   indent = '  '.repeat(prefix.split('.').length - 1);
   {
     let name;
@@ -359,13 +387,11 @@ function printTree(node, siblingNum) {
   all.sort((a, b) => a.pos - b.pos);
 
   for (let entry of all)
-    if (entry.type === 'item')
+    if (entry.type == 'item')
       print(indent
             + '  ' + entry.data.type.padEnd(5)
             + ' ' + entry.data.name
-            // B: is the ref conditional within the scope that "owns" the ref (for single statement `if`)
             + (entry.data.ctx ? ' ' + entry.data.ctx : '').padEnd(3)
-            // C: is the ref conditional within the variable's narrowestScope?
             + (entry.data.isConditional ? 'C' : ' ').padEnd(2)
             + 'pos ' + entry.data.pos);
     else
@@ -384,6 +410,7 @@ function createNarrowestScope
         let tree, scopeToNode;
 
         scopeToNode = new Map;
+        nextVarId = 0;
         tree = buildScopeTree(scopeManager.scopes[0], '1', scopeToNode);
         checkScopeNode(context, tree, null, scopeToNode);
         printTree(tree, 0);
@@ -391,6 +418,12 @@ function createNarrowestScope
     }
 }
 
+var narrowestScopePlugin = { meta: { type: 'suggestion',
+                  docs: { description: 'Enforce variables are declared in their narrowest possible scope.' },
+                  messages: { tooBroad: 'Variable "{{ name }}" is declared in a broader scope than necessary.' },
+                  schema: [] },
+          create: createNarrowestScope };
+
 function createPositiveVibes
 (context) {
   return {
@@ -410,18 +443,463 @@ function createPositiveVibes
   }
 }
 
-plugins = { 'cookshack': { rules: { 'positive-vibes': { meta: { type: 'problem',
-                                                                docs: { description: 'Prefer positive expressions.' },
-                                                                messages: { positiveVibes: 'Be positive!',
-                                                                            equality: 'Use ==.',
-                                                                            strictEquality: 'Use ===.' },
-                                                                schema: [] },
-                                                        create: createPositiveVibes },
-                                    'narrowest-scope': { meta: { type: 'suggestion',
-                                                                 docs: { description: 'Enforce variables are declared in their narrowest possible scope.' },
-                                                                 messages: { tooBroad: 'Variable "{{ name }}" is declared in a broader scope than necessary.' },
-                                                                 schema: [] },
-                                                         create: createNarrowestScope } } } };
+var positiveVibesPlugin = { meta: { type: 'problem',
+                  docs: { description: 'Prefer positive expressions.' },
+                  messages: { positiveVibes: 'Be positive!',
+                              equality: 'Use ==.',
+                              strictEquality: 'Use ===.' },
+                  schema: [] },
+          create: createPositiveVibes };
+
+var useRiskyEqualPlugin = { meta: { type: 'problem',
+                  docs: { description: 'Enforce use of == instead of ===.' },
+                  messages: { risky: 'Use ==.' },
+                  schema: [] },
+          create(context) {
+            return { BinaryExpression(node) {
+              if (node.operator == '===')
+                context.report({ node, messageId: 'risky' });
+            } }
+          } };
+
+function create$2
+(context) {
+  return { VariableDeclaration(node) {
+    if (node.kind == 'const' || node.kind == 'var')
+      context.report({ node, messageId: 'useLet' });
+  } }
+}
+
+var alwaysLetPlugin = { meta: { type: 'problem',
+                  docs: { description: 'Enforce use of let instead of const or var.' },
+                  messages: { useLet: 'Use let.' },
+                  schema: [] },
+          create: create$2 };
+
+let ostIdCounter, ost;
+
+ostIdCounter = 0;
+ost = 0;
+
+function trace
+(...args) {
+}
+
+function createInitBeforeUse(context) {
+  let scopeManager;
+
+  scopeManager = context.sourceCode.scopeManager;
+  if (scopeManager)
+    return {
+      'Program:exit'() {
+        let scopeToNode, astToTree, astToOst;
+        scopeToNode = new Map;
+        astToTree = new Map;
+        astToOst = new Map;
+        buildScopeTree(scopeManager.scopes[0], '1', scopeToNode, astToTree);
+
+        ostIdCounter = 0;
+        ost = processAst(context.sourceCode.ast, null, astToTree, astToOst, '', new Set());
+
+        ostAnnotate(ost, astToOst, context);
+
+        ostCheck(ost, context);
+      }
+    }
+}
+
+function isRegularDeclaration
+(item) {
+  if (item.type == 'LET') {
+    if (item.defType == 'FunctionName' || item.defType == 'Parameter')
+      return 0
+    return 1
+  }
+  return 0
+}
+
+function processAst(astNode, parentOst, astToTree, astToOst, indent, visited) {
+  if (astNode) {
+    let treeNode, scopeName, lets, reads, writes, ost, children;
+
+    if (visited.has(astNode))
+      return
+    visited.add(astNode);
+
+    treeNode = astToTree.get(astNode) ?? parentOst?.treeNode;
+
+    scopeName = treeNode?.scope ? `${treeNode.scope.type}` : 'no-scope';
+    if (treeNode?.scope?.block?.id?.name)
+      scopeName += `(${treeNode.scope.block.id.name})`;
+    trace(`${indent}${astNode.type}`);
+
+    lets = [];
+    reads = [];
+    writes = [];
+
+    for (let item of treeNode?.items ?? [])
+      if (isRegularDeclaration(item)) {
+        let scopeCreator;
+
+        scopeCreator = treeNode?.scope?.block;
+        if (scopeCreator && astNode == scopeCreator) {
+          lets.push({ item });
+          trace(`${indent}  | LET ${item.name}:${item.varId}`);
+        }
+      }
+      else if (item.ref)
+        if (astNode == item.ref.identifier)
+          if (item.type == 'READ') {
+            reads.push({ item });
+            trace(`${indent}  | READ ${item.name}:${item.varId}`);
+          }
+          else if (item.type == 'WRITE') {
+            writes.push({ item });
+            trace(`${indent}  | WRITE ${item.name}:${item.varId}`);
+          }
+
+    ost = {
+      id: ostIdCounter++,
+      astNode,
+      treeNode,
+      scopeItems: treeNode?.items ?? [],
+      lets,
+      reads,
+      writes,
+      children: [],
+      fnDefOst: null
+    };
+
+    astToOst.set(astNode, ost);
+
+    children = [];
+
+    if (astNode.type == 'ForOfStatement' || astNode.type == 'ForInStatement') {
+      if (astNode.right)
+        children.push(astNode.right);
+      if (astNode.left)
+        children.push(astNode.left);
+      if (astNode.body)
+        children.push(astNode.body);
+    }
+    else if (astNode.type == 'ForStatement') {
+      if (astNode.init)
+        children.push(astNode.init);
+      if (astNode.test)
+        children.push(astNode.test);
+      if (astNode.update)
+        children.push(astNode.update);
+      if (astNode.body)
+        children.push(astNode.body);
+    }
+    else if (astNode.type == 'AssignmentExpression') {
+      if (astNode.right)
+        children.push(astNode.right);
+      if (astNode.left)
+        children.push(astNode.left);
+    }
+    else {
+      if (astNode.body)
+        if (Array.isArray(astNode.body))
+          children.push(...astNode.body);
+        else
+          children.push(astNode.body);
+      if (astNode.consequent)
+        children.push(astNode.consequent);
+      if (astNode.alternate)
+        children.push(astNode.alternate);
+      if (astNode.block)
+        children.push(astNode.block);
+      if (astNode.expression)
+        children.push(astNode.expression);
+      if (astNode.callee)
+        children.push(astNode.callee);
+      if (astNode.object)
+        children.push(astNode.object);
+      if (astNode.property)
+        children.push(astNode.property);
+      if (astNode.init)
+        children.push(astNode.init);
+      if (astNode.id)
+        children.push(astNode.id);
+      if (astNode.declarations)
+        children.push(...astNode.declarations);
+      if (astNode.test)
+        children.push(astNode.test);
+      if (astNode.update)
+        children.push(astNode.update);
+      if (astNode.left)
+        children.push(astNode.left);
+      if (astNode.right)
+        children.push(astNode.right);
+      if (astNode.argument)
+        children.push(astNode.argument);
+      if (astNode.arguments)
+        children.push(...astNode.arguments);
+      if (astNode.elements)
+        children.push(...astNode.elements);
+      if (astNode.properties)
+        children.push(...astNode.properties);
+    }
+
+    for (let child of children) {
+      let childOst;
+
+      childOst = processAst(child, ost, astToTree, astToOst, indent + '  ', visited);
+      if (childOst)
+        ost.children.push(childOst);
+    }
+
+    return ost
+  }
+}
+
+function ostAnnotate(ost, astToOst, context) {
+  if (ost) {
+    for (let letInfo of ost.lets) {
+      let writeOst;
+
+      writeOst = findFirstWrite(ost, letInfo);
+      letInfo.firstWrite = writeOst;
+      if (writeOst)
+        continue
+      if (letInfo.item.defType == 'ImportBinding')
+        continue
+      context.report({
+        node: letInfo.item.identifier,
+        messageId: 'mustInit',
+        data: { name: letInfo.item.name }
+      });
+    }
+
+    if (ost.astNode.type == 'CallExpression' && ost.astNode.callee?.type == 'Identifier')
+      for (let child of ost.children)
+        if (child.astNode == ost.astNode.callee && child.reads.length > 0) {
+          let readRef;
+
+          readRef = child.reads[0].item.ref;
+          if (readRef?.resolved) {
+            let variable;
+
+            variable = readRef.resolved;
+            if (variable.defs.length > 0) {
+              let fnDefAst;
+
+              fnDefAst = variable.defs[0].node;
+              if (fnDefAst) {
+                if (fnDefAst.init?.type == 'ArrowFunctionExpression' || fnDefAst.init?.type == 'FunctionExpression')
+                  fnDefAst = fnDefAst.init;
+                ost.fnDefOst = astToOst.get(fnDefAst);
+              }
+            }
+          }
+        }
+
+    for (let child of ost.children)
+      ostAnnotate(child, astToOst, context);
+  }
+}
+
+function findFirstWrite(ost, letInfo) {
+  if (ost.astNode.type == 'FunctionDeclaration' || ost.astNode.type == 'ArrowFunctionExpression' || ost.astNode.type == 'FunctionExpression')
+    for (let child of ost.children)
+      if (child.astNode.type == 'BlockStatement')
+        return findFirstWriteInSubtree(child, letInfo)
+  return findFirstWriteInSubtree(ost, letInfo)
+}
+
+function findFirstWriteInSubtree(ost, letInfo) {
+  if (ost) {
+    if (ost.astNode.type == 'FunctionDeclaration' || ost.astNode.type == 'ArrowFunctionExpression' || ost.astNode.type == 'FunctionExpression')
+      return null
+
+    for (let writeInfo of ost.writes) {
+      let writeVar;
+
+      writeVar = writeInfo.item.ref.resolved;
+      if (writeVar == letInfo.item.variable)
+        return ost
+    }
+
+    for (let child of ost.children) {
+      let result;
+
+      result = findFirstWriteInSubtree(child, letInfo);
+      if (result)
+        return result
+    }
+  }
+
+  return null
+}
+
+function ostCheck(ost, context) {
+  if (ost) {
+    for (let letInfo of ost.lets)
+      if (letInfo.firstWrite)
+        walk2Start(ost, letInfo, context);
+
+    for (let child of ost.children)
+      ostCheck(child, context);
+  }
+}
+
+function walk2Start(node, letInfo, context) {
+  if (node.astNode.type == 'FunctionDeclaration')
+    for (let child of node.children)
+      if (child.astNode.type == 'BlockStatement')
+        return walk2(child, letInfo, context, new Set())
+  return walk2(node, letInfo, context, new Set())
+}
+
+function walk2(node, letInfo, context, visited) {
+  if (node) {
+    if (node.astNode.type == 'FunctionDeclaration' || node.astNode.type == 'ArrowFunctionExpression' || node.astNode.type == 'FunctionExpression')
+      return false
+
+    if (node == letInfo.firstWrite) {
+      for (let readInfo of node.reads)
+        if (readInfo.item.ref.resolved == letInfo.item.variable) {
+          context.report({
+            node: readInfo.item.ref.identifier,
+            messageId: 'initBeforeUse',
+            data: { name: letInfo.item.name }
+          });
+        }
+      return true
+    }
+
+    if (node.astNode.type == 'CallExpression' && node.fnDefOst) {
+      let fnType;
+
+      fnType = node.fnDefOst.astNode.type;
+
+      if (fnType == 'FunctionDeclaration' || fnType == 'ArrowFunctionExpression' || fnType == 'FunctionExpression') {
+        let key;
+
+        key = `${letInfo.item.name}:${node.fnDefOst.id}`;
+        if (visited.has(key)) ;
+        else {
+          visited.add(key);
+          for (let child of node.fnDefOst.children)
+            if (child.astNode.type == 'BlockStatement' && walk2(child, letInfo, context, visited))
+              return true
+        }
+      }
+    }
+
+    for (let readInfo of node.reads)
+      if (readInfo.item.ref.resolved == letInfo.item.variable) {
+        context.report({
+          node: readInfo.item.ref.identifier,
+          messageId: 'initBeforeUse',
+          data: { name: letInfo.item.name }
+        });
+      }
+
+    for (let child of node.children)
+      if (walk2(child, letInfo, context, visited))
+        return true
+  }
+
+  return false
+}
+
+var initBeforeUsePlugin = {
+  meta: {
+    type: 'problem',
+    docs: { description: 'Warn when a variable is used before being explicitly initialized.' },
+    messages: { initBeforeUse: "'{{name}}' used before initialization.",
+                mustInit: "'{{name}}' must be initialized." },
+    schema: []
+  },
+  create: createInitBeforeUse
+};
+
+function
+VariableDeclaration
+(context, node) {
+  let parent;
+
+  parent = node.parent;
+
+  for (parent = node.parent; parent; parent = parent.parent)
+    if (parent.type == 'BlockStatement')
+      break
+
+  if (parent) {
+    let idx;
+
+    if (parent.parent?.type == 'CatchClause')
+      return
+
+    idx = parent.body.indexOf(node);
+    for (let i = 0; i < idx; i++) {
+      if (parent.body[i].type == 'VariableDeclaration')
+        continue
+      context.report({ node, messageId: 'varDeclBlockStart' });
+      return
+    }
+  }
+}
+function create$1
+(context) {
+  return { VariableDeclaration: node => VariableDeclaration(context, node) }
+}
+
+var varDeclBlockStartPlugin = { meta: { type: 'suggestion',
+                  docs: { description: 'Require variable declarations to be at the start of the block.' },
+                  messages: { varDeclBlockStart: 'VarDecl must be at start of block.' },
+                  schema: [] },
+          create: create$1 };
+
+function
+FunctionDeclaration
+(context, node) {
+  let parent;
+
+  for (parent = node.parent; parent; parent = parent.parent)
+    if (parent.type == 'BlockStatement')
+      break
+
+  if (parent) {
+    let idx;
+
+    if (parent.parent?.type == 'CatchClause')
+      return
+
+    idx = parent.body.indexOf(node);
+    for (let i = 0; i < idx; i++) {
+      if (parent.body[i].type == 'VariableDeclaration'
+          || parent.body[i].type == 'FunctionDeclaration'
+          || parent.body[i].type == 'EmptyStatement')
+        continue
+      context.report({ node, messageId: 'fnDeclBlockStart' });
+      return
+    }
+  }
+}
+
+function create
+(context) {
+  return { FunctionDeclaration: node => FunctionDeclaration(context, node) }
+}
+
+var fnDeclBlockStartPlugin = { meta: { type: 'suggestion',
+                  docs: { description: 'Require function declarations to be at the start of the block.' },
+                  messages: { fnDeclBlockStart: 'FnDecl must be the start the block (after VarDecls).' },
+                  schema: [] },
+          create };
+
+let rules, languageOptions, plugins;
+
+plugins = { 'cookshack': { rules: { 'positive-vibes': positiveVibesPlugin,
+                                    'narrowest-scope': narrowestScopePlugin,
+                                    'use-risky-equal': useRiskyEqualPlugin,
+                                    'always-let': alwaysLetPlugin,
+                                    'init-before-use': initBeforeUsePlugin,
+                                    'var-decl-block-start': varDeclBlockStartPlugin,
+                                    'fn-decl-block-start': fnDeclBlockStartPlugin } } };
 
 rules = {
   'array-bracket-newline': [ 'error', 'never' ],
@@ -452,8 +930,14 @@ rules = {
                                        { blankLine: 'never', prev: 'let', next: 'let' } ],
   'no-case-declarations': 'error',
   'no-global-assign': 'error',
-  'cookshack/narrowest-scope': 'error',
   'cookshack/positive-vibes': 'error',
+  'cookshack/narrowest-scope': 'error',
+  'cookshack/use-risky-equal': 'error',
+  'cookshack/always-let': 'error',
+  // using the implicit inititialization to undefined fits better
+  //'cookshack/init-before-use': 'error',
+  'cookshack/var-decl-block-start': 'error',
+  'cookshack/fn-decl-block-start': 'error',
   'no-mixed-operators': 'error',
   'no-multi-spaces': 'error',
   'no-multiple-empty-lines': [ 'error', { max: 1, maxEOF: 0 } ],