@atlisp/lint 0.1.3 → 0.1.5

package/dist/checks/recursive-call.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRecursiveCall = checkRecursiveCall;
+exports.checkRecursiveCallAst = checkRecursiveCallAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkRecursiveCall(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkRecursiveCallAst(ast, file);
+}
+function checkRecursiveCallAst(ast, file) {
+    const issues = [];
+    const defuns = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'defun'));
+    for (const defun of defuns) {
+        if (!defun.children || defun.children.length < 3)
+            continue;
+        const nameNode = defun.children[1];
+        const funcName = nameNode.type === 'symbol' && nameNode.name ? nameNode.name : '';
+        if (!funcName)
+            continue;
+        // Walk the function body (skip name and param list)
+        for (let i = 3; i < defun.children.length; i++) {
+            if (hasSelfCall(defun.children[i], funcName)) {
+                issues.push({
+                    file,
+                    line: defun.pos.line,
+                    severity: 'warn',
+                    rule: 'recursive_call',
+                    message: (0, locale_1.t)('recursive_call', funcName),
+                });
+                break; // one issue per function
+            }
+        }
+    }
+    return issues;
+}
+function hasSelfCall(node, funcName) {
+    for (const n of (0, parser_1.astWalk)(node)) {
+        // Check if this node is a list whose car is the function name
+        if (n.type === 'list' && n.children && n.children.length > 0) {
+            const car = n.children[0];
+            if (car.type === 'symbol' && car.name === funcName) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=recursive-call.js.map

package/dist/checks/redundant-cond.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkRedundantCond(content: string, file: string): Issue[];
+export declare function checkRedundantCondAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=redundant-cond.d.ts.map

package/dist/checks/redundant-cond.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRedundantCond = checkRedundantCond;
+exports.checkRedundantCondAst = checkRedundantCondAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkRedundantCond(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkRedundantCondAst(ast, file);
+}
+function checkRedundantCondAst(ast, file) {
+    const issues = [];
+    const condNodes = (0, parser_1.astFindListWithHead)(ast, 'cond');
+    for (const node of condNodes) {
+        if (!node.children)
+            continue;
+        const clauses = node.children.slice(1); // skip 'cond' itself
+        // Single clause cond: (cond (test body)) → (if test body)
+        if (clauses.length === 1) {
+            const clause = clauses[0];
+            if (clause.type === 'list' && clause.children && clause.children.length >= 2) {
+                issues.push({
+                    file,
+                    line: node.pos.line,
+                    severity: 'warn',
+                    rule: 'redundant_cond',
+                    message: (0, locale_1.t)('redundant_cond.single', 'cond'),
+                });
+            }
+        }
+        // Two-clause cond with T/t as last condition: (cond (x y) (T z)) → (if x y z)
+        if (clauses.length === 2) {
+            const last = clauses[clauses.length - 1];
+            if (last.type === 'list' && last.children && last.children.length > 0) {
+                const condTest = last.children[0];
+                if (condTest.type === 'symbol' && (condTest.name === 'T' || condTest.name === 't')) {
+                    issues.push({
+                        file,
+                        line: condTest.pos.line,
+                        severity: 'warn',
+                        rule: 'redundant_cond',
+                        message: (0, locale_1.t)('redundant_cond.t_last', 'cond'),
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=redundant-cond.js.map

package/dist/checks/redundant-let.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkRedundantLet(content: string, file: string): Issue[];
+export declare function checkRedundantLetAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=redundant-let.d.ts.map

package/dist/checks/redundant-let.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRedundantLet = checkRedundantLet;
+exports.checkRedundantLetAst = checkRedundantLetAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkRedundantLet(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkRedundantLetAst(ast, file);
+}
+function checkRedundantLetAst(ast, file) {
+    const issues = [];
+    const letNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'let'));
+    for (const node of letNodes) {
+        if (!node.children || node.children.length < 2)
+            continue;
+        const bindings = node.children[1];
+        // (let () ...) — binding list exists but is empty
+        if (bindings.type === 'list' && (!bindings.children || bindings.children.length === 0)) {
+            issues.push({
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'redundant_let',
+                message: (0, locale_1.t)('redundant_let'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=redundant-let.js.map

package/dist/checks/redundant-nil-else.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkRedundantNilElse(content: string, file: string): Issue[];
+export declare function checkRedundantNilElseAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=redundant-nil-else.d.ts.map

package/dist/checks/redundant-nil-else.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRedundantNilElse = checkRedundantNilElse;
+exports.checkRedundantNilElseAst = checkRedundantNilElseAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkRedundantNilElse(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkRedundantNilElseAst(ast, file);
+}
+function checkRedundantNilElseAst(ast, file) {
+    const issues = [];
+    // Find (if cond then nil) — else branch is nil which is the default
+    const ifNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'if'));
+    for (const node of ifNodes) {
+        if (!node.children || node.children.length !== 4)
+            continue;
+        // (if cond then nil) — 4 children: if, cond, then, nil-else
+        const elseBranch = node.children[3];
+        if (elseBranch.type === 'symbol' && elseBranch.name === 'nil') {
+            issues.push({
+                file,
+                line: elseBranch.pos.line,
+                severity: 'warn',
+                rule: 'redundant_nil_else',
+                message: (0, locale_1.t)('redundant_nil_else'),
+            });
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=redundant-nil-else.js.map

package/dist/checks/redundant-progn.d.ts

@@ -1,3 +1,5 @@
 import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
 export declare function checkRedundantProgn(content: string, file: string): Issue[];
+export declare function checkRedundantPrognAst(ast: AstNode, file: string): Issue[];
 //# sourceMappingURL=redundant-progn.d.ts.map

package/dist/checks/redundant-progn.js

@@ -1,19 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkRedundantProgn = checkRedundantProgn;
+exports.checkRedundantPrognAst = checkRedundantPrognAst;
 const locale_1 = require("../locale");
-const utils_1 = require("../utils");
+const parser_1 = require("@atlisp/parser");
 function checkRedundantProgn(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkRedundantPrognAst(ast, file);
+}
+function checkRedundantPrognAst(ast, file) {
     const issues = [];
-    const lines = content.split('\n');
-    for (let i = 0; i < lines.length; i++) {
-        const stripped = (0, utils_1.stripLine)(lines[i]).trim();
-        // Detect (if expr (progn ...) ...) or (cond ((t) (progn ...)))
-        const m = stripped.match(/\((if|when|unless|cond)\s+.+\(progn\b/);
-        if (m) {
+    const prognNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'progn'));
+    for (const node of prognNodes) {
+        if (!node.children)
+            continue;
+        // count forms after 'progn'
+        const bodyCount = node.children.length - 1;
+        if (bodyCount === 1) {
             issues.push({
-                file, line: i + 1, severity: 'warn', rule: 'redundant_progn',
-                message: (0, locale_1.t)('redundant_progn'),
+                file,
+                line: node.pos.line,
+                severity: 'warn',
+                rule: 'redundant_progn',
+                message: (0, locale_1.t)('redundant_progn', '(progn ...)'),
             });
         }
     }

package/dist/checks/redundant-quotes.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkRedundantQuotes(content: string, file: string): Issue[];
+export declare function checkRedundantQuotesAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=redundant-quotes.d.ts.map

package/dist/checks/redundant-quotes.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRedundantQuotes = checkRedundantQuotes;
+exports.checkRedundantQuotesAst = checkRedundantQuotesAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkRedundantQuotes(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkRedundantQuotesAst(ast, file);
+}
+function checkRedundantQuotesAst(ast, file) {
+    const issues = [];
+    // ''x → (quote (quote x)) — nested quote
+    const doubleQuotes = (0, parser_1.astFindAll)(ast, (n) => {
+        if (!(0, parser_1.astIsList)(n, 'quote'))
+            return false;
+        if (!n.children || n.children.length < 2)
+            return false;
+        return (0, parser_1.astIsList)(n.children[1], 'quote');
+    });
+    for (const node of doubleQuotes) {
+        issues.push({
+            file,
+            line: node.pos.line,
+            severity: 'warn',
+            rule: 'redundant_quotes',
+            message: (0, locale_1.t)('redundant_quotes'),
+        });
+    }
+    // '(quote x) → (quote (quote x)) — same representation via AST
+    return issues;
+}
+//# sourceMappingURL=redundant-quotes.js.map

package/dist/checks/redundant-setq.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkRedundantSetq(content: string, file: string): Issue[];
+export declare function checkRedundantSetqAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=redundant-setq.d.ts.map

package/dist/checks/redundant-setq.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkRedundantSetq = checkRedundantSetq;
+exports.checkRedundantSetqAst = checkRedundantSetqAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkRedundantSetq(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkRedundantSetqAst(ast, file);
+}
+function checkRedundantSetqAst(ast, file) {
+    const issues = [];
+    const setqNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'setq'));
+    for (const node of setqNodes) {
+        if (!node.children)
+            continue;
+        // (setq x x) — variable is set to itself
+        for (let i = 1; i < node.children.length - 1; i += 2) {
+            const varNode = node.children[i];
+            const valNode = node.children[i + 1];
+            if (varNode.type === 'symbol' && valNode.type === 'symbol' && varNode.name === valNode.name && varNode.name) {
+                issues.push({
+                    file,
+                    line: varNode.pos.line,
+                    severity: 'warn',
+                    rule: 'redundant_setq',
+                    message: (0, locale_1.t)('redundant_setq', varNode.name),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=redundant-setq.js.map

package/dist/checks/self-compare.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkSelfCompare(content: string, file: string): Issue[];
+export declare function checkSelfCompareAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=self-compare.d.ts.map

package/dist/checks/self-compare.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSelfCompare = checkSelfCompare;
+exports.checkSelfCompareAst = checkSelfCompareAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+const COMPARE_FUNCTIONS = new Set(['=', '/=', '<', '>', '<=', '>=', 'eq', 'equal']);
+function checkSelfCompare(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkSelfCompareAst(ast, file);
+}
+function checkSelfCompareAst(ast, file) {
+    const issues = [];
+    for (const fn of COMPARE_FUNCTIONS) {
+        const nodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, fn));
+        for (const node of nodes) {
+            if (!node.children)
+                continue;
+            // (= x x) — 3 children: '=', x, x
+            if (node.children.length === 3) {
+                const a = node.children[1];
+                const b = node.children[2];
+                if (a.type === 'symbol' && b.type === 'symbol' && a.name === b.name && a.name) {
+                    issues.push({
+                        file,
+                        line: node.pos.line,
+                        severity: 'warn',
+                        rule: 'self_compare',
+                        message: (0, locale_1.t)('self_compare', `(${fn} ${a.name} ${a.name})`),
+                    });
+                }
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=self-compare.js.map

package/dist/checks/single-arg-and-or.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkSingleArgAndOr(content: string, file: string): Issue[];
+export declare function checkSingleArgAndOrAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=single-arg-and-or.d.ts.map

package/dist/checks/single-arg-and-or.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkSingleArgAndOr = checkSingleArgAndOr;
+exports.checkSingleArgAndOrAst = checkSingleArgAndOrAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkSingleArgAndOr(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkSingleArgAndOrAst(ast, file);
+}
+function checkSingleArgAndOrAst(ast, file) {
+    const issues = [];
+    for (const form of ['and', 'or']) {
+        const nodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, form));
+        for (const node of nodes) {
+            if (!node.children)
+                continue;
+            // (and x) — 2 children: 'and', x
+            if (node.children.length === 2) {
+                issues.push({
+                    file,
+                    line: node.pos.line,
+                    severity: 'warn',
+                    rule: 'single_arg_and_or',
+                    message: (0, locale_1.t)('single_arg_and_or', `(${form} ...)`),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=single-arg-and-or.js.map

package/dist/checks/token-in-url.js

@@ -11,7 +11,10 @@ function checkTokenInUrl(content, file) {
         for (const s of strings) {
             if (/token=/i.test(s)) {
                 issues.push({
-                    file, line: i + 1, severity: 'warn', rule: 'token_in_url',
+                    file,
+                    line: i + 1,
+                    severity: 'warn',
+                    rule: 'token_in_url',
                     message: (0, locale_1.t)('token_in_url'),
                 });
                 break; // one per line

package/dist/checks/trailing-paren.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkTrailingParen(content: string, file: string): Issue[];
+//# sourceMappingURL=trailing-paren.d.ts.map

package/dist/checks/trailing-paren.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkTrailingParen = checkTrailingParen;
+const locale_1 = require("../locale");
+function checkTrailingParen(content, file) {
+    // Count total parens to detect excess closing parens
+    let openCount = 0;
+    let closeCount = 0;
+    let inStr = false;
+    // We must parse strings accurately to avoid counting parens inside strings
+    for (let i = 0; i < content.length; i++) {
+        const ch = content[i];
+        if (ch === '"')
+            inStr = !inStr;
+        if (inStr) {
+            if (ch === '\\')
+                i++; // skip escaped char
+            continue;
+        }
+        if (ch === ';') {
+            // skip to end of line
+            while (i < content.length && content[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (ch === '(')
+            openCount++;
+        else if (ch === ')')
+            closeCount++;
+    }
+    if (closeCount > openCount) {
+        return [
+            {
+                file,
+                line: 1,
+                severity: 'warn',
+                rule: 'trailing_paren',
+                message: (0, locale_1.t)('trailing_paren', closeCount - openCount),
+            },
+        ];
+    }
+    return [];
+}
+//# sourceMappingURL=trailing-paren.js.map

package/dist/checks/trailing-ws.js

@@ -9,7 +9,10 @@ function checkTrailingWhitespace(content, file) {
         const line = lines[i];
         if (line.length > 0 && /[ \t]$/.test(line)) {
             issues.push({
-                file, line: i + 1, severity: 'warn', rule: 'trailing_whitespace',
+                file,
+                line: i + 1,
+                severity: 'warn',
+                rule: 'trailing_whitespace',
                 message: (0, locale_1.t)('trailing_whitespace'),
             });
         }

package/dist/checks/unused-let.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkUnusedLetBinding(content: string, file: string): Issue[];
+export declare function checkUnusedLetBindingAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=unused-let.d.ts.map

package/dist/checks/unused-let.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUnusedLetBinding = checkUnusedLetBinding;
+exports.checkUnusedLetBindingAst = checkUnusedLetBindingAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkUnusedLetBinding(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkUnusedLetBindingAst(ast, file);
+}
+function checkUnusedLetBindingAst(ast, file) {
+    const issues = [];
+    const letNodes = (0, parser_1.astFindAll)(ast, (n) => (0, parser_1.astIsList)(n, 'let'));
+    for (const node of letNodes) {
+        if (!node.children || node.children.length < 2)
+            continue;
+        const bindingList = node.children[1];
+        if (bindingList.type !== 'list' || !bindingList.children)
+            continue;
+        // Collect let-bound variables
+        const bindings = [];
+        for (const binding of bindingList.children) {
+            if (binding.type !== 'list' || !binding.children || binding.children.length === 0)
+                continue;
+            const varNode = binding.children[0];
+            if (varNode.type !== 'symbol' || !varNode.name)
+                continue;
+            if (varNode.name === 'T' || varNode.name === 'nil')
+                continue;
+            bindings.push({ name: varNode.name, node: varNode });
+        }
+        if (bindings.length === 0)
+            continue;
+        // Collect symbol references in the body (forms after the binding list)
+        const bodyRefs = new Set();
+        for (let i = 2; i < node.children.length; i++) {
+            for (const n of (0, parser_1.astWalk)(node.children[i])) {
+                if (n.type === 'symbol' && n.name) {
+                    bodyRefs.add(n.name);
+                }
+            }
+        }
+        for (const { name, node: varNode } of bindings) {
+            if (!bodyRefs.has(name)) {
+                issues.push({
+                    file,
+                    line: varNode.pos.line,
+                    severity: 'warn',
+                    rule: 'unused_let_binding',
+                    message: (0, locale_1.t)('unused_let_binding', name),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=unused-let.js.map

package/dist/checks/unused-local-fun.d.ts

@@ -0,0 +1,5 @@
+import { Issue } from '../types';
+import { AstNode } from '@atlisp/parser';
+export declare function checkUnusedLocalFun(content: string, file: string): Issue[];
+export declare function checkUnusedLocalFunAst(ast: AstNode, file: string): Issue[];
+//# sourceMappingURL=unused-local-fun.d.ts.map

package/dist/checks/unused-local-fun.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkUnusedLocalFun = checkUnusedLocalFun;
+exports.checkUnusedLocalFunAst = checkUnusedLocalFunAst;
+const locale_1 = require("../locale");
+const parser_1 = require("@atlisp/parser");
+function checkUnusedLocalFun(content, file) {
+    const ast = (0, parser_1.parseAst)(content);
+    return checkUnusedLocalFunAst(ast, file);
+}
+function checkUnusedLocalFunAst(ast, file) {
+    const issues = [];
+    const defuns = (0, parser_1.astFindListWithHead)(ast, 'defun');
+    for (const defun of defuns) {
+        if (!defun.children || defun.children.length < 3)
+            continue;
+        const paramList = defun.children[2];
+        if (paramList.type !== 'list' || !paramList.children)
+            continue;
+        // Collect local variables after `/` in param list
+        // (defun foo (x / y z) ...) → y, z are local vars
+        const locals = [];
+        let afterSlash = false;
+        for (const p of paramList.children) {
+            if (p.type === 'symbol' && p.name === '/') {
+                afterSlash = true;
+                continue;
+            }
+            if (!afterSlash)
+                continue;
+            if (p.type !== 'symbol' || !p.name)
+                continue;
+            if (p.name === 'T' || p.name === 'nil')
+                continue;
+            locals.push({ name: p.name, node: p });
+        }
+        if (locals.length === 0)
+            continue;
+        // Collect symbol references in the body (forms after param list, skip params)
+        const bodyRefs = new Set();
+        for (let i = 3; i < defun.children.length; i++) {
+            for (const n of (0, parser_1.astWalk)(defun.children[i])) {
+                if (n.type === 'symbol' && n.name) {
+                    bodyRefs.add(n.name);
+                }
+            }
+        }
+        for (const { name, node } of locals) {
+            if (!bodyRefs.has(name)) {
+                issues.push({
+                    file,
+                    line: node.pos.line,
+                    severity: 'warn',
+                    rule: 'unused_local_fun',
+                    message: (0, locale_1.t)('unused_local_fun', name),
+                });
+            }
+        }
+    }
+    return issues;
+}
+//# sourceMappingURL=unused-local-fun.js.map

package/dist/checks/unused-package-dep.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from '../types';
+export declare function checkUnusedPackageDep(file: string): Issue[];
+//# sourceMappingURL=unused-package-dep.d.ts.map