@thethracian/oxlint-config 0.2.0 → 0.3.0

package/dist/rules/effect-source-scan.js

@@ -1,17 +1,213 @@
+/* -------------------------------------------------------------------------- */
+/*              Source scanning utilities for Effect lint rules.              */
+/* -------------------------------------------------------------------------- */
+import { CHAR_CLASS, CLS_DIGIT, CLS_LOWER, CLS_UNDER, CLS_UPPER } from './char-class.js';
 const regexPrefixChars = new Set(['(', '[', '{', '=', ':', ',', ';', '!', '?', '&', '|']);
 const regexPrefixWords = new Set(['case', 'delete', 'return', 'throw', 'typeof', 'void', 'yield']);
 const STRIP_CACHE_MAX = 256;
-const commentCache = new Map();
 const codeOnlyCache = new Map();
-function cached(cache, source) {
-    const value = cache.get(source);
-    if (value !== undefined) {
-        cache.delete(source);
-        cache.set(source, value);
+const IDENTIFIER_MASK = CLS_UPPER | CLS_LOWER | CLS_DIGIT | CLS_UNDER;
+const CHAR_CODE_SPACE = 32;
+const CHAR_CODE_TAB = 9;
+const CHAR_CODE_NEWLINE = 10;
+const CHAR_CODE_CARRIAGE_RETURN = 13;
+const CHAR_CODE_VERTICAL_TAB = 11;
+const CHAR_CODE_FORM_FEED = 12;
+const CHAR_CODE_DOLLAR = 36;
+const isWhitespaceCode = (code) => code === CHAR_CODE_SPACE ||
+    code === CHAR_CODE_TAB ||
+    code === CHAR_CODE_NEWLINE ||
+    code === CHAR_CODE_CARRIAGE_RETURN ||
+    code === CHAR_CODE_VERTICAL_TAB ||
+    code === CHAR_CODE_FORM_FEED;
+const appendNewlineOrBlank = (output, char) => {
+    if (char === '\n') {
+        return output + char;
     }
-    return value;
-}
-function cacheResult(cache, source, value) {
+    return `${output} `;
+};
+const appendPreservedOrBlank = (output, shouldPreserve, char) => {
+    if (shouldPreserve) {
+        return output + char;
+    }
+    return `${output} `;
+};
+const lineCommentStep = (state, char) => {
+    if (char === '\n') {
+        return {
+            ...state,
+            isLineComment: false,
+            stripped: state.stripped + char,
+        };
+    }
+    return {
+        ...state,
+        stripped: `${state.stripped} `,
+    };
+};
+const blockCommentStep = (state, char, nextChar) => {
+    if (char === '*' && nextChar === '/') {
+        return {
+            ...state,
+            index: state.index + 1,
+            isBlockComment: false,
+            stripped: `${state.stripped}  `,
+        };
+    }
+    return {
+        ...state,
+        stripped: appendNewlineOrBlank(state.stripped, char),
+    };
+};
+const templateInterpolationStartStep = (state) => ({
+    ...state,
+    index: state.index + 1,
+    quote: '',
+    stripped: `${state.stripped}  `,
+    templateExpressionDepth: state.templateExpressionDepth + 1,
+});
+const quotedStep = (state, char, nextChar) => {
+    const shouldPreserve = char === '\n';
+    if (state.quote === '`' && char === '$' && nextChar === '{' && !state.isEscaped) {
+        return templateInterpolationStartStep(state);
+    }
+    if (state.isEscaped) {
+        return {
+            ...state,
+            isEscaped: false,
+            stripped: appendNewlineOrBlank(state.stripped, char),
+        };
+    }
+    if (char === '\\') {
+        return {
+            ...state,
+            isEscaped: true,
+            stripped: appendNewlineOrBlank(state.stripped, char),
+        };
+    }
+    if (char === state.quote) {
+        return {
+            ...state,
+            quote: '',
+            stripped: state.stripped + char,
+        };
+    }
+    return {
+        ...state,
+        stripped: appendPreservedOrBlank(state.stripped, shouldPreserve || char === state.quote, char),
+    };
+};
+const templateBraceStep = (state, char) => {
+    if (state.templateExpressionDepth <= 0) {
+        return undefined;
+    }
+    if (char === '{') {
+        return {
+            ...state,
+            stripped: state.stripped + char,
+            templateExpressionDepth: state.templateExpressionDepth + 1,
+        };
+    }
+    if (char !== '}') {
+        return undefined;
+    }
+    const templateExpressionDepth = state.templateExpressionDepth - 1;
+    if (templateExpressionDepth === 0) {
+        return {
+            ...state,
+            quote: '`',
+            stripped: `${state.stripped} `,
+            templateExpressionDepth,
+        };
+    }
+    return {
+        ...state,
+        stripped: state.stripped + char,
+        templateExpressionDepth,
+    };
+};
+const codeStep = (source, state, char, nextChar) => {
+    if (char === '/' && nextChar === '/') {
+        return {
+            ...state,
+            index: state.index + 1,
+            isLineComment: true,
+            stripped: `${state.stripped}  `,
+        };
+    }
+    if (char === '/' && nextChar === '*') {
+        return {
+            ...state,
+            index: state.index + 1,
+            isBlockComment: true,
+            stripped: `${state.stripped}  `,
+        };
+    }
+    if (isREGEXLiteralStart(source, state.index)) {
+        const endIndex = findREGEXLiteralEnd(source, state.index);
+        return {
+            ...state,
+            index: endIndex,
+            stripped: state.stripped + ' '.repeat(endIndex - state.index + 1),
+        };
+    }
+    if (char === '"' || char === "'" || char === '`') {
+        return { ...state, quote: char, stripped: state.stripped + char };
+    }
+    return { ...state, stripped: state.stripped + char };
+};
+const stripCodeOnlyStep = (source, state) => {
+    const char = source[state.index];
+    const nextChar = source[state.index + 1];
+    if (state.isLineComment) {
+        return lineCommentStep(state, char);
+    }
+    if (state.isBlockComment) {
+        return blockCommentStep(state, char, nextChar);
+    }
+    if (state.quote) {
+        return quotedStep(state, char, nextChar);
+    }
+    return templateBraceStep(state, char) ?? codeStep(source, state, char, nextChar);
+};
+const initialStripState = () => ({
+    index: 0,
+    isBlockComment: false,
+    isEscaped: false,
+    isLineComment: false,
+    quote: '',
+    stripped: '',
+    templateExpressionDepth: 0,
+});
+const isASCIIIdentifierChar = (source, index) => {
+    const code = source.charCodeAt(index);
+    return (code === CHAR_CODE_DOLLAR ||
+        (code < CHAR_CLASS.length && (CHAR_CLASS[code] & IDENTIFIER_MASK) !== 0));
+};
+const isASCIILetter = (source, index) => {
+    const code = source.charCodeAt(index);
+    return code < CHAR_CLASS.length && (CHAR_CLASS[code] & (CLS_UPPER | CLS_LOWER)) !== 0;
+};
+const quoteStart = (char) => {
+    if (char === '"' || char === "'" || char === '`') {
+        return char;
+    }
+    return '';
+};
+const nextQuoteState = (state, char) => {
+    if (state.isEscaped) {
+        return { ...state, isEscaped: false };
+    }
+    if (char === '\\') {
+        return { ...state, isEscaped: true };
+    }
+    if (char === state.quote) {
+        return { isEscaped: false, quote: '' };
+    }
+    return state;
+};
+const cached = (cache, source) => cache.get(source);
+const cacheResult = (cache, source, value) => {
     if (cache.size >= STRIP_CACHE_MAX) {
         const firstKey = cache.keys().next().value;
         if (firstKey !== undefined) {
@@ -20,27 +216,32 @@ function cacheResult(cache, source, value) {
     }
     cache.set(source, value);
     return value;
-}
-function previousSignificantIndex(source, index) {
+};
+const previousSignificantIndex = (source, index) => {
     for (let cursor = index - 1; cursor >= 0; cursor--) {
-        if (!/\s/.test(source[cursor])) {
+        if (!isWhitespaceCode(source.charCodeAt(cursor))) {
             return cursor;
         }
     }
     return -1;
-}
-function wordBefore(source, index) {
+};
+const wordBefore = (source, index) => {
     const endIndex = previousSignificantIndex(source, index);
-    if (endIndex === -1 || !/[\w$]/.test(source[endIndex])) {
+    if (endIndex === -1 || !isASCIIIdentifierChar(source, endIndex)) {
         return '';
     }
     let startIndex = endIndex;
-    while (startIndex > 0 && /[\w$]/.test(source[startIndex - 1])) {
+    while (startIndex > 0 && isASCIIIdentifierChar(source, startIndex - 1)) {
         startIndex--;
     }
     return source.slice(startIndex, endIndex + 1);
-}
-function isRegexLiteralStart(source, index) {
+};
+/**
+ * Internal helper exported for package-local composition.
+ *
+ * @internal
+ */
+export const isREGEXLiteralStart = (source, index) => {
     if (source[index] !== '/' || source[index + 1] === '/' || source[index + 1] === '*') {
         return false;
     }
@@ -49,308 +250,187 @@ function isRegexLiteralStart(source, index) {
         return true;
     }
     return (regexPrefixChars.has(source[previousIndex]) || regexPrefixWords.has(wordBefore(source, index)));
-}
-function findRegexLiteralEnd(source, startIndex) {
+};
+const regexFlagsEndIndex = (source, index) => {
+    let flagsEndIndex = index;
+    while (isASCIILetter(source, flagsEndIndex + 1)) {
+        flagsEndIndex++;
+    }
+    return flagsEndIndex;
+};
+const scanREGEXDelimiter = (source, index, isCharacterClass) => {
+    const char = source[index];
+    if (char === '\n') {
+        return { endIndex: -1, isCharacterClass, isEscaped: false };
+    }
+    if (char === '/' && !isCharacterClass) {
+        return { endIndex: regexFlagsEndIndex(source, index), isCharacterClass, isEscaped: false };
+    }
+    return undefined;
+};
+const scanREGEXCharacterClass = (char, isCharacterClass) => {
+    if (char === '[') {
+        return { isCharacterClass: true, isEscaped: false };
+    }
+    if (char === ']') {
+        return { isCharacterClass: false, isEscaped: false };
+    }
+    return { isCharacterClass, isEscaped: false };
+};
+const scanREGEXLiteralChar = (source, index, isEscaped, isCharacterClass) => {
+    const char = source[index];
+    if (isEscaped) {
+        return { isCharacterClass, isEscaped: false };
+    }
+    if (char === '\\') {
+        return { isCharacterClass, isEscaped: true };
+    }
+    const delimiter = scanREGEXDelimiter(source, index, isCharacterClass);
+    if (delimiter) {
+        return delimiter;
+    }
+    return scanREGEXCharacterClass(char, isCharacterClass);
+};
+/**
+ * Internal helper exported for package-local composition.
+ *
+ * @internal
+ */
+export const findREGEXLiteralEnd = (source, startIndex) => {
     let isEscaped = false;
     let isCharacterClass = false;
     for (let index = startIndex + 1; index < source.length; index++) {
-        const char = source[index];
-        if (isEscaped) {
-            isEscaped = false;
-            continue;
-        }
-        if (char === '\\') {
-            isEscaped = true;
-            continue;
-        }
-        if (char === '[') {
-            isCharacterClass = true;
-            continue;
-        }
-        if (char === ']') {
-            isCharacterClass = false;
-            continue;
-        }
-        if (char === '\n') {
+        const result = scanREGEXLiteralChar(source, index, isEscaped, isCharacterClass);
+        if (result.endIndex === -1) {
             return startIndex;
         }
-        if (char === '/' && !isCharacterClass) {
-            let flagsEndIndex = index;
-            while (/[a-z]/i.test(source[flagsEndIndex + 1] ?? '')) {
-                flagsEndIndex++;
-            }
-            return flagsEndIndex;
+        if (result.endIndex !== undefined) {
+            return result.endIndex;
         }
+        ({ isCharacterClass, isEscaped } = result);
     }
     return startIndex;
-}
-function findBalancedCallEnd(source, openParenIndex) {
+};
+const skipLineCommentIndex = (source, index) => {
+    const newlineIndex = source.indexOf('\n', index + 2);
+    if (newlineIndex === -1) {
+        return source.length;
+    }
+    return newlineIndex;
+};
+const skipBlockCommentIndex = (source, index) => {
+    const commentEnd = source.indexOf('*/', index + 2);
+    if (commentEnd === -1) {
+        return source.length;
+    }
+    return commentEnd + 1;
+};
+const skipNonCodeIndex = (source, index) => {
+    const char = source[index];
+    const nextChar = source[index + 1];
+    if (char === '/' && nextChar === '/') {
+        return skipLineCommentIndex(source, index);
+    }
+    if (char === '/' && nextChar === '*') {
+        return skipBlockCommentIndex(source, index);
+    }
+    if (isREGEXLiteralStart(source, index)) {
+        return findREGEXLiteralEnd(source, index);
+    }
+    return undefined;
+};
+const quoteOrNonCodeScan = (source, index, quoteState) => {
+    const char = source[index];
+    if (quoteState.quote) {
+        return { index, quoteState: nextQuoteState(quoteState, char) };
+    }
+    const quote = quoteStart(char);
+    if (quote) {
+        return { index, quoteState: { isEscaped: false, quote } };
+    }
+    const nonCodeIndex = skipNonCodeIndex(source, index);
+    if (nonCodeIndex !== undefined) {
+        return { index: nonCodeIndex, quoteState };
+    }
+    return undefined;
+};
+const nextBalancedCallScan = (source, index, depth, quoteState) => {
+    const quoteOrNonCode = quoteOrNonCodeScan(source, index, quoteState);
+    if (quoteOrNonCode) {
+        return { ...quoteOrNonCode, depth, isEnd: false };
+    }
+    const char = source[index];
+    if (char === '(') {
+        return { depth: depth + 1, index, isEnd: false, quoteState };
+    }
+    if (char !== ')') {
+        return { depth, index, isEnd: false, quoteState };
+    }
+    return { depth: depth - 1, index, isEnd: depth - 1 === 0, quoteState };
+};
+/**
+ * Internal helper exported for package-local composition.
+ *
+ * @internal
+ */
+export const findBalancedCallEnd = (source, openParenIndex) => {
     let depth = 0;
-    let quote = '';
-    let isEscaped = false;
+    let quoteState = { isEscaped: false, quote: '' };
     for (let index = openParenIndex; index < source.length; index++) {
-        const char = source[index];
-        const nextChar = source[index + 1];
-        if (quote) {
-            if (isEscaped) {
-                isEscaped = false;
-            }
-            else if (char === '\\') {
-                isEscaped = true;
-            }
-            else if (char === quote) {
-                quote = '';
-            }
-            continue;
-        }
-        if (char === '/' && nextChar === '/') {
-            const newlineIndex = source.indexOf('\n', index + 2);
-            index = newlineIndex === -1 ? source.length : newlineIndex;
-            continue;
-        }
-        if (char === '/' && nextChar === '*') {
-            const commentEnd = source.indexOf('*/', index + 2);
-            index = commentEnd === -1 ? source.length : commentEnd + 1;
-            continue;
-        }
-        if (isRegexLiteralStart(source, index)) {
-            index = findRegexLiteralEnd(source, index);
-            continue;
-        }
-        if (char === '"' || char === "'" || char === '`') {
-            quote = char;
-            continue;
-        }
-        if (char === '(') {
-            depth++;
-        }
-        else if (char === ')') {
-            depth--;
-            if (depth === 0) {
-                return index;
-            }
+        const next = nextBalancedCallScan(source, index, depth, quoteState);
+        if (next.isEnd) {
+            return index;
         }
+        ({ depth, index, quoteState } = next);
     }
     return source.length - 1;
-}
-function stripComments(source) {
-    const cachedValue = cached(commentCache, source);
-    if (cachedValue !== undefined) {
-        return cachedValue;
+};
+const nextBraceScan = (source, index, depth, quoteState) => {
+    const quoteOrNonCode = quoteOrNonCodeScan(source, index, quoteState);
+    if (quoteOrNonCode) {
+        return { ...quoteOrNonCode, depth, isEnd: false };
     }
-    let stripped = '';
-    let quote = '';
-    let isEscaped = false;
-    let isLineComment = false;
-    let isBlockComment = false;
-    for (let index = 0; index < source.length; index++) {
-        const char = source[index];
-        const nextChar = source[index + 1];
-        if (isLineComment) {
-            if (char === '\n') {
-                isLineComment = false;
-                stripped += char;
-            }
-            else {
-                stripped += ' ';
-            }
-            continue;
-        }
-        if (isBlockComment) {
-            if (char === '*' && nextChar === '/') {
-                isBlockComment = false;
-                stripped += '  ';
-                index++;
-            }
-            else {
-                stripped += char === '\n' ? char : ' ';
-            }
-            continue;
-        }
-        if (quote) {
-            if (isEscaped) {
-                isEscaped = false;
-            }
-            else if (char === '\\') {
-                isEscaped = true;
-            }
-            else if (char === quote) {
-                quote = '';
-            }
-            stripped += char;
-            continue;
-        }
-        if (char === '/' && nextChar === '/') {
-            isLineComment = true;
-            stripped += '  ';
-            index++;
-            continue;
-        }
-        if (char === '/' && nextChar === '*') {
-            isBlockComment = true;
-            stripped += '  ';
-            index++;
-            continue;
-        }
-        if (isRegexLiteralStart(source, index)) {
-            const endIndex = findRegexLiteralEnd(source, index);
-            stripped += source.slice(index, endIndex + 1);
-            index = endIndex;
-            continue;
-        }
-        if (char === '"' || char === "'" || char === '`') {
-            quote = char;
-        }
-        stripped += char;
+    const char = source[index];
+    if (char === '{') {
+        return { depth: depth + 1, index, isEnd: false, quoteState };
     }
-    return cacheResult(commentCache, source, stripped);
-}
-function stripCommentsAndStrings(source) {
+    if (char !== '}') {
+        return { depth, index, isEnd: false, quoteState };
+    }
+    return { depth: depth - 1, index, isEnd: depth - 1 === 0, quoteState };
+};
+/**
+ * Internal helper exported for package-local composition.
+ *
+ * @internal
+ */
+export const stripCommentsAndStrings = (source) => {
     const cachedValue = cached(codeOnlyCache, source);
     if (cachedValue !== undefined) {
         return cachedValue;
     }
-    let stripped = '';
-    let quote = '';
-    let isEscaped = false;
-    let isLineComment = false;
-    let isBlockComment = false;
-    let templateExpressionDepth = 0;
-    for (let index = 0; index < source.length; index++) {
-        const char = source[index];
-        const nextChar = source[index + 1];
-        if (isLineComment) {
-            if (char === '\n') {
-                isLineComment = false;
-                stripped += char;
-            }
-            else {
-                stripped += ' ';
-            }
-            continue;
-        }
-        if (isBlockComment) {
-            if (char === '*' && nextChar === '/') {
-                isBlockComment = false;
-                stripped += '  ';
-                index++;
-            }
-            else {
-                stripped += char === '\n' ? char : ' ';
-            }
-            continue;
-        }
-        if (quote) {
-            const currentQuote = quote;
-            let shouldPreserve = char === '\n';
-            if (quote === '`' && char === '$' && nextChar === '{' && !isEscaped) {
-                templateExpressionDepth++;
-                quote = '';
-                stripped += '  ';
-                index++;
-                continue;
-            }
-            if (isEscaped) {
-                isEscaped = false;
-            }
-            else if (char === '\\') {
-                isEscaped = true;
-            }
-            else if (char === quote) {
-                shouldPreserve = true;
-                quote = '';
-            }
-            stripped += shouldPreserve || char === currentQuote ? char : ' ';
-            continue;
-        }
-        if (templateExpressionDepth > 0) {
-            if (char === '{') {
-                templateExpressionDepth++;
-            }
-            else if (char === '}') {
-                templateExpressionDepth--;
-                if (templateExpressionDepth === 0) {
-                    stripped += ' ';
-                    quote = '`';
-                    continue;
-                }
-            }
-        }
-        if (char === '/' && nextChar === '/') {
-            isLineComment = true;
-            stripped += '  ';
-            index++;
-            continue;
-        }
-        if (char === '/' && nextChar === '*') {
-            isBlockComment = true;
-            stripped += '  ';
-            index++;
-            continue;
-        }
-        if (isRegexLiteralStart(source, index)) {
-            const endIndex = findRegexLiteralEnd(source, index);
-            stripped += ' '.repeat(endIndex - index + 1);
-            index = endIndex;
-            continue;
-        }
-        if (char === '"' || char === "'" || char === '`') {
-            quote = char;
-            stripped += char;
-            continue;
-        }
-        stripped += char;
+    let state = initialStripState();
+    while (state.index < source.length) {
+        const stepped = stripCodeOnlyStep(source, state);
+        state = { ...stepped, index: stepped.index + 1 };
     }
-    return cacheResult(codeOnlyCache, source, stripped);
-}
-function findMatchingBrace(source, openIndex) {
+    return cacheResult(codeOnlyCache, source, state.stripped);
+};
+/**
+ * Internal helper exported for package-local composition.
+ *
+ * @internal
+ */
+export const findMatchingBrace = (source, openIndex) => {
     let depth = 0;
-    let quote = '';
-    let isEscaped = false;
+    let quoteState = { isEscaped: false, quote: '' };
     for (let index = openIndex; index < source.length; index++) {
-        const char = source[index];
-        const nextChar = source[index + 1];
-        if (quote) {
-            if (isEscaped) {
-                isEscaped = false;
-            }
-            else if (char === '\\') {
-                isEscaped = true;
-            }
-            else if (char === quote) {
-                quote = '';
-            }
-            continue;
-        }
-        if (char === '/' && nextChar === '/') {
-            const newlineIndex = source.indexOf('\n', index + 2);
-            index = newlineIndex === -1 ? source.length : newlineIndex;
-            continue;
-        }
-        if (char === '/' && nextChar === '*') {
-            const commentEnd = source.indexOf('*/', index + 2);
-            index = commentEnd === -1 ? source.length : commentEnd + 1;
-            continue;
-        }
-        if (isRegexLiteralStart(source, index)) {
-            index = findRegexLiteralEnd(source, index);
-            continue;
-        }
-        if (char === '"' || char === "'" || char === '`') {
-            quote = char;
-            continue;
-        }
-        if (char === '{') {
-            depth++;
-        }
-        else if (char === '}') {
-            depth--;
-            if (depth === 0) {
-                return index;
-            }
+        const next = nextBraceScan(source, index, depth, quoteState);
+        if (next.isEnd) {
+            return index;
         }
+        ({ depth, index, quoteState } = next);
     }
     return -1;
-}
-export { findBalancedCallEnd, findMatchingBrace, findRegexLiteralEnd, isRegexLiteralStart, stripComments, stripCommentsAndStrings, };
+};
 //# sourceMappingURL=effect-source-scan.js.map