flatlint 4.13.0 → 5.0.0

package/ChangeLog

@@ -1,3 +1,25 @@
+2026.02.17, v5.0.0
+
+feature:
+- e97e93a compare: for-of
+- 39351ad feature: compare: match-token -> match
+- aa77d10 cursor: getIndex: add
+- d582e38 flatlint: compare: move out cursor
+- 8c238c4 flatlint: compare: move out match-token
+- 49281ca flatlint: compare: matchers
+- 0ddcf54 compare: simplify
+
+2026.02.17, v4.13.1
+
+fix:
+- a3a40b5 flatlint: squire -> square
+- 376082e flatlint: add-missing-square-brace: inner
+
+feature:
+- 5dcdd09 flatlint: madrun v13.0.0
+- 8de4017 flatlint: putout v42.0.3
+- 67e23ea flatlint: eslint-plugin-putout v31.0.0
+
 2026.02.17, v4.13.0
 
 feature:

package/lib/compare/compare.js

@@ -1,120 +1,59 @@
 import {prepare} from '#parser';
-import {
-    isTemplateArgsToken,
-    isTemplateArrayToken,
-    isTemplateExpressionToken,
-    OK,
-    NOT_OK,
-} from '#types';
-import {collectArray} from './collect-array.js';
-import {collectExpression} from './collect-expression.js';
-import {collectArgs} from './collect-args.js';
-import {equalTemplate} from './equal.js';
+import {OK, NOT_OK} from '#types';
+import {match} from './match.js';
+import {createCursor} from './cursor.js';
 
 export const compare = (source, template, {index = 0} = {}) => {
-    const templateTokens = prepare(template);
     const tokens = prepare(source);
+    const templateTokens = prepare(template);
     
-    const n = tokens.length - 1;
-    const templateTokensLength = templateTokens.length;
-    
-    let isEqual = false;
-    let start = 0;
-    let end = 0;
-    let delta = 0;
+    const lastTokenIndex = tokens.length - 1;
+    const lastTemplateIndex = templateTokens.length - 1;
     
-    for (; index < n; index++) {
-        const indexCheck = index;
-        let skip = 0;
+    for (; index <= lastTokenIndex; index++) {
+        const cursor = createCursor({
+            index,
+            tokens,
+            templateTokens,
+            lastTokenIndex,
+        });
         
-        for (const [templateIndex] of templateTokens.entries()) {
-            let currentTokenIndex = index + templateIndex - skip;
+        for (const [templateIndex, templateToken] of templateTokens.entries()) {
+            const nextTemplateToken = templateTokens[templateIndex + 1];
+            const isLast = templateIndex === lastTemplateIndex;
             
-            checkIndexes(index, indexCheck);
+            const {
+                matched,
+                skip,
+                end,
+            } = match(cursor, {
+                templateToken,
+                nextTemplateToken,
+                templateIndex,
+                isLast,
+            });
             
-            if (currentTokenIndex > n)
-                return [NOT_OK];
-            
-            const templateToken = templateTokens[templateIndex];
-            const currentToken = tokens[currentTokenIndex];
-            
-            if (isTemplateArgsToken(templateToken)) {
-                const [ok, end] = collectArgs({
-                    currentTokenIndex,
-                    tokens,
-                    templateToken,
-                    nextTemplateToken: templateTokens[templateIndex + 1],
-                });
-                
-                delta = 0;
-                
-                if (!ok) {
-                    ++skip;
-                } else if (templateIndex === templateTokensLength - 1) {
-                    currentTokenIndex = end;
-                } else if (currentTokenIndex < end) {
-                    delta = end - currentTokenIndex;
-                    index = end - templateIndex;
-                }
-            } else if (isTemplateExpressionToken(templateToken)) {
-                const indexOfExpressionEnd = collectExpression({
-                    currentTokenIndex,
-                    tokens,
-                    templateToken,
-                    nextTemplateToken: templateTokens[templateIndex + 1],
-                });
-                
-                const sameTokensIndex = templateIndex === templateTokensLength - 1;
-                const outOfBound = indexOfExpressionEnd >= n;
-                
-                if (outOfBound || sameTokensIndex) {
-                    end = indexOfExpressionEnd;
-                    currentTokenIndex = end;
-                } else {
-                    delta = indexOfExpressionEnd - currentTokenIndex;
-                    index = indexOfExpressionEnd - templateIndex;
+            if (!matched) {
+                if (skip) {
+                    cursor.skip();
+                    continue;
                 }
-            } else if (isTemplateArrayToken(templateToken)) {
-                const [ok, end] = collectArray({
-                    currentTokenIndex,
-                    tokens,
-                    templateToken,
-                    nextTemplateToken: templateTokens[templateIndex + 1],
-                });
                 
-                if (!ok) {
-                    ++skip;
-                } else if (currentTokenIndex < end) {
-                    delta = end - currentTokenIndex;
-                    index = end - templateIndex;
-                }
-            } else if (!equalTemplate(currentToken, templateToken)) {
-                isEqual = false;
+                cursor.setUnmatched();
                 break;
             }
             
-            isEqual = true;
-            start = index - delta;
-            end = currentTokenIndex;
+            cursor.setMatched(end);
         }
         
-        if (isEqual)
+        if (cursor.isMatched())
             return [
                 OK,
-                start,
-                ++end,
+                cursor.state.start,
+                cursor.state.end + 1,
             ];
     }
     
     return [NOT_OK];
 };
 
-function checkIndexes(index, indexCheck) {
-    /* c8 ignore start */
-    if (indexCheck > index + 1)
-        throw Error(`index should never decrease more then on one: ${index} > ${indexCheck}`);
-    
-    if (index < 0)
-        throw Error(`index should never be < zero: ${index}`);
-    /* c8 ignore end */
-}

package/lib/compare/cursor.js

@@ -0,0 +1,51 @@
+export function createCursor({index, tokens, templateTokens, lastTokenIndex}) {
+    const state = {
+        index,
+        delta: 0,
+        skip: 0,
+        start: 0,
+        end: 0,
+        matched: false,
+    };
+    
+    return {
+        tokens,
+        templateTokens,
+        lastTokenIndex,
+        state,
+        
+        getIndex(templateIndex) {
+            return this.state.index + templateIndex - this.state.skip;
+        },
+        
+        getToken(templateIndex) {
+            const index = this.getIndex(templateIndex);
+            return this.tokens[index];
+        },
+        
+        skip() {
+            state.skip++;
+        },
+        
+        setMatched(end) {
+            state.matched = true;
+            state.start = state.index - state.delta;
+            state.end = end;
+        },
+        
+        setUnmatched() {
+            state.matched = false;
+        },
+        
+        isMatched() {
+            return state.matched;
+        },
+        
+        updateDelta(currentTokenIndex, end, templateIndex) {
+            if (currentTokenIndex < end) {
+                state.delta = end - currentTokenIndex;
+                state.index = end - templateIndex;
+            }
+        },
+    };
+}

package/lib/compare/match.js

@@ -0,0 +1,54 @@
+import {equalTemplate} from './equal.js';
+import {matchers} from './matchers/index.js';
+
+const SKIP = {
+    skip: true,
+    matched: false,
+};
+
+const NOT_MATCHED = {
+    matched: false,
+};
+
+const createMatched = (a) => ({
+    ...a,
+    matched: true,
+});
+
+export function match(cursor, {templateToken, templateIndex, nextTemplateToken, isLast}) {
+    const {tokens} = cursor;
+    const currentTokenIndex = cursor.getIndex(templateIndex);
+    
+    if (currentTokenIndex > cursor.lastTokenIndex)
+        return NOT_MATCHED;
+    
+    const currentToken = cursor.getToken(templateIndex);
+    
+    for (const {testToken, collect} of matchers) {
+        if (!testToken(templateToken))
+            continue;
+        
+        const [ok, end] = collect({
+            currentTokenIndex,
+            tokens,
+            templateToken,
+            nextTemplateToken,
+        });
+        
+        if (!ok)
+            return SKIP;
+        
+        cursor.updateDelta(currentTokenIndex, end, templateIndex);
+        
+        return createMatched({
+            end: isLast ? end : currentTokenIndex,
+        });
+    }
+    
+    if (!equalTemplate(currentToken, templateToken))
+        return NOT_MATCHED;
+    
+    return createMatched({
+        end: currentTokenIndex,
+    });
+}

package/lib/compare/{collect-args.js → matchers/args.js}

@@ -3,13 +3,14 @@ import {
     closeRoundBrace,
     isNewLine,
     isPunctuator,
+    isTemplateArgs,
     NOT_OK,
     OK,
     openCurlyBrace,
     openRoundBrace,
     semicolon,
 } from '#types';
-import {equal} from './equal.js';
+import {equal} from '../equal.js';
 
 const NOT_OK_PUNCTUATORS = [
     semicolon,
@@ -17,7 +18,9 @@ const NOT_OK_PUNCTUATORS = [
     closeRoundBrace,
 ];
 
-export const collectArgs = ({currentTokenIndex, tokens}) => {
+export const test = isTemplateArgs;
+
+export const collect = ({currentTokenIndex, tokens}) => {
     let index = currentTokenIndex;
     
     const n = tokens.length;

package/lib/compare/{collect-array.js → matchers/array.js}

@@ -4,10 +4,13 @@ import {
     semicolon,
     OK,
     NOT_OK,
+    isTemplateArray,
 } from '#types';
-import {equal} from './equal.js';
+import {equal} from '../equal.js';
 
-export const collectArray = ({currentTokenIndex, tokens, nextTemplateToken = semicolon}) => {
+export const test = isTemplateArray;
+
+export const collect = ({currentTokenIndex, tokens, nextTemplateToken = semicolon}) => {
     const n = tokens.length;
     let index = currentTokenIndex;
     

package/lib/compare/{collect-expression.js → matchers/expression.js}

@@ -3,13 +3,16 @@ import {
     closeRoundBrace,
     comma,
     isNewLine,
+    isTemplateExpression,
     openCurlyBrace,
     openRoundBrace,
     semicolon,
 } from '#types';
-import {equal} from './equal.js';
+import {equal} from '../equal.js';
 
-export const collectExpression = ({currentTokenIndex, tokens, nextTemplateToken = semicolon}) => {
+export const test = isTemplateExpression;
+
+export const collect = ({currentTokenIndex, tokens, nextTemplateToken = semicolon}) => {
     const n = tokens.length;
     let index = currentTokenIndex;
     let roundBracesBalance = 0;
@@ -52,7 +55,10 @@ export const collectExpression = ({currentTokenIndex, tokens, nextTemplateToken
         --index;
     
     if (currentTokenIndex === index)
-        return currentTokenIndex;
+        return [true, currentTokenIndex];
     
-    return --index;
+    return [
+        true,
+        --index,
+    ];
 };

package/lib/compare/matchers/index.js

@@ -0,0 +1,25 @@
+import {isIdentifier} from '#types';
+import * as argsMatcher from './args.js';
+import * as arrayMatcher from './array.js';
+import * as expressionMatcher from './expression.js';
+
+export const matchers = [
+    argsMatcher,
+    arrayMatcher,
+    expressionMatcher,
+].map(createMatcher);
+
+function createMatcher({test, collect, testToken}) {
+    return {
+        collect,
+        test,
+        testToken: testToken || ((token) => {
+            const {value} = token;
+            
+            if (!isIdentifier(token))
+                return false;
+            
+            return test(value);
+        }),
+    };
+}

package/lib/compare/values.js

@@ -1,14 +1,9 @@
 import {traverse} from '#traverser';
 import {prepare} from '#parser';
-import {
-    is,
-    isTemplateArgs,
-    isTemplateArray,
-    isTemplateExpression,
-} from '#types';
-import {collectArray} from './collect-array.js';
-import {collectExpression} from './collect-expression.js';
-import {collectArgs} from './collect-args.js';
+import {is} from '#types';
+import * as arrayMatcher from './matchers/array.js';
+import * as expressionMatcher from './matchers/expression.js';
+import * as argsMatcher from './matchers/args.js';
 
 const {isArray} = Array;
 const maybeArray = (a) => isArray(a) ? a : [a];
@@ -41,18 +36,18 @@ export function getValues(tokens, waysFrom) {
         let end = index;
         let ok = true;
         
-        if (isTemplateArray(name)) {
-            [ok, end] = collectArray({
+        if (arrayMatcher.test(name)) {
+            [ok, end] = arrayMatcher.collect({
                 currentTokenIndex: index,
                 tokens,
             });
-        } else if (isTemplateExpression(name)) {
-            end = collectExpression({
+        } else if (expressionMatcher.test(name)) {
+            [ok, end] = expressionMatcher.collect({
                 currentTokenIndex: index,
                 tokens,
             });
-        } else if (isTemplateArgs(name)) {
-            [ok, end] = collectArgs({
+        } else if (argsMatcher.test(name)) {
+            [ok, end] = argsMatcher.collect({
                 currentTokenIndex: index,
                 tokens,
             });

package/lib/plugins/add-missing-square-brace/index.js

@@ -1,41 +1,18 @@
 import {
     closeCurlyBrace,
-    comma,
     isPunctuator,
-    openSquireBrace,
 } from '#types';
 
 export const report = () => 'Add missing square brace';
 
-const addIndex = (a, i) => [i, a];
-
 export const match = () => ({
     '["__a"': (vars, path) => !path.isNext(),
     '[__array;': ({__array}) => {
         const last = __array.at(-1);
         return !isPunctuator(last, closeCurlyBrace);
     },
-    '"__a",\n}': (vars, path) => {
-        const allPrevs = path
-            .getAllPrev()
-            .map(addIndex);
-        
-        let is = false;
-        
-        for (const [i, prev] of allPrevs) {
-            const COMMA_POSITION = '\n",'.length;
-            
-            if (i === COMMA_POSITION) {
-                is = isPunctuator(prev, [comma, openSquireBrace]);
-                break;
-            }
-        }
-        
-        return is;
-    },
 });
 export const replace = () => ({
-    '"__a",\n}': '"__a",\n]}',
     '[__array;': '[__array];',
     '["__a"': '["__a"];',
     '[;': '[];',
@@ -44,4 +21,3 @@ export const replace = () => ({
     '(__a, [__b)': '(__a, [__b])',
     '(__a, [__b, __c)': '(__a, [__b, __c])',
 });
-

package/lib/plugins.js

@@ -37,7 +37,7 @@ export const plugins = [
     ['add-missing-assign', addMissingAssign],
     ['add-missing-curly-brace', addMissingCurlyBrace],
     ['add-missing-round-brace', addMissingRoundBrace],
-    ['add-missing-squire-brace', addMissingSquireBrace],
+    ['add-missing-square-brace', addMissingSquireBrace],
     ['apply-import-from', applyImportFrom],
     ['apply-import-order', applyImportOrder],
     ['convert-assert-to-with', convertAssertToWith],

package/lib/types/types.js

@@ -139,9 +139,6 @@ export const isQuote = (a) => QUOTE.test(a);
 export const isTemplateArray = (a) => a === ARRAY;
 export const isTemplateExpression = (a) => a === EXPR;
 export const isTemplateArgs = (a) => a === ARGS;
-export const isTemplateArrayToken = (a) => isIdentifier(a) && isTemplateArray(a.value);
-export const isTemplateExpressionToken = (a) => isIdentifier(a) && isTemplateExpression(a.value);
-export const isTemplateArgsToken = (a) => isIdentifier(a) && isTemplateArgs(a.value);
 
 export const bitwiseAnd = Punctuator('&');
 export const arrow = Punctuator('=>');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flatlint",
-  "version": "4.13.0",
+  "version": "5.0.0",
   "description": "JavaScript tokens-based linter",
   "main": "lib/flatlint.js",
   "type": "module",
@@ -68,12 +68,12 @@
     "@putout/test": "^15.0.0",
     "c8": "^10.1.2",
     "eslint": "^10.0.0",
-    "eslint-plugin-putout": "^30.0.1",
-    "madrun": "^12.1.0",
+    "eslint-plugin-putout": "^31.0.0",
+    "madrun": "^13.0.0",
     "mock-require": "^3.0.3",
     "montag": "^1.0.0",
     "nodemon": "^3.0.1",
-    "putout": "^41.0.2",
+    "putout": "^42.0.3",
     "supertape": "^12.0.0"
   },
   "engines": {