New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@stylistic/eslint-plugin-ts

Package Overview
Dependencies
Maintainers
0
Versions
74
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@stylistic/eslint-plugin-ts - npm Package Compare versions

Comparing version 3.1.0 to 4.0.0-beta.1

63

dist/configs.js

@@ -1,29 +0,27 @@

'use strict';
import { d as createAllConfigs } from './utils.js';
import blockSpacing from './rules/block-spacing.js';
import braceStyle from './rules/brace-style.js';
import commaDangle from './rules/comma-dangle.js';
import commaSpacing from './rules/comma-spacing.js';
import functionCallSpacing from './rules/function-call-spacing.js';
import indent from './rules/indent.js';
import keySpacing from './rules/key-spacing.js';
import keywordSpacing from './rules/keyword-spacing.js';
import linesAroundComment from './rules/lines-around-comment.js';
import linesBetweenClassMembers from './rules/lines-between-class-members.js';
import memberDelimiterStyle from './rules/member-delimiter-style.js';
import noExtraParens from './rules/no-extra-parens.js';
import noExtraSemi from './rules/no-extra-semi.js';
import objectCurlyNewline from './rules/object-curly-newline.js';
import objectCurlySpacing from './rules/object-curly-spacing.js';
import objectPropertyNewline from './rules/object-property-newline.js';
import paddingLineBetweenStatements from './rules/padding-line-between-statements.js';
import quoteProps from './rules/quote-props.js';
import quotes from './rules/quotes.js';
import semi from './rules/semi.js';
import spaceBeforeBlocks from './rules/space-before-blocks.js';
import spaceBeforeFunctionParen from './rules/space-before-function-paren.js';
import spaceInfixOps from './rules/space-infix-ops.js';
import typeAnnotationSpacing from './rules/type-annotation-spacing.js';
var utils = require('./utils.js');
var blockSpacing = require('./rules/block-spacing.js');
var braceStyle = require('./rules/brace-style.js');
var commaDangle = require('./rules/comma-dangle.js');
var commaSpacing = require('./rules/comma-spacing.js');
var functionCallSpacing = require('./rules/function-call-spacing.js');
var indent = require('./rules/indent.js');
var keySpacing = require('./rules/key-spacing.js');
var keywordSpacing = require('./rules/keyword-spacing.js');
var linesAroundComment = require('./rules/lines-around-comment.js');
var linesBetweenClassMembers = require('./rules/lines-between-class-members.js');
var memberDelimiterStyle = require('./rules/member-delimiter-style.js');
var noExtraParens = require('./rules/no-extra-parens.js');
var noExtraSemi = require('./rules/no-extra-semi.js');
var objectCurlyNewline = require('./rules/object-curly-newline.js');
var objectCurlySpacing = require('./rules/object-curly-spacing.js');
var objectPropertyNewline = require('./rules/object-property-newline.js');
var paddingLineBetweenStatements = require('./rules/padding-line-between-statements.js');
var quoteProps = require('./rules/quote-props.js');
var quotes = require('./rules/quotes.js');
var semi = require('./rules/semi.js');
var spaceBeforeBlocks = require('./rules/space-before-blocks.js');
var spaceBeforeFunctionParen = require('./rules/space-before-function-paren.js');
var spaceInfixOps = require('./rules/space-infix-ops.js');
var typeAnnotationSpacing = require('./rules/type-annotation-spacing.js');
var rules = {

@@ -90,9 +88,12 @@ "block-spacing": blockSpacing,

const all = /* @__PURE__ */ createAllConfigs(plugin, "@stylistic/ts");
const configs = {
"disable-legacy": config,
"all-flat": utils.createAllConfigs(plugin, "@stylistic/ts", true),
"all-extends": utils.createAllConfigs(plugin, "@stylistic/ts", false)
all,
/**
* @deprecated use `all` instead.
*/
"all-flat": all
};
exports.configs = configs;
exports.plugin = plugin;
export { configs as c, plugin as p };

10

dist/dts/index.d.ts

@@ -13,3 +13,3 @@ import { Rule, Linter } from 'eslint';

/**
* Disable all legacy rules from `@typescript-eslint`
* Disable all legacy rules from `eslint`
*

@@ -22,7 +22,9 @@ * This config works for both flat and legacy config format

*/
'all-flat': Linter.Config
'all': Linter.Config
/**
* Enable all rules, in Legacy Config Format
* Enable all rules, in Flat Config Format
*
* @deprecated use `all` instead
*/
'all-extends': Linter.BaseConfig
'all-flat': Linter.Config
}

@@ -29,0 +31,0 @@ }

66

dist/index.js

@@ -1,36 +0,34 @@

'use strict';
import { p as plugin, c as configs } from './configs.js';
import './utils.js';
import 'eslint-visitor-keys';
import 'espree';
import './rules/block-spacing.js';
import '@typescript-eslint/utils';
import '@typescript-eslint/utils/ast-utils';
import './rules/brace-style.js';
import './rules/comma-dangle.js';
import './rules/comma-spacing.js';
import './rules/function-call-spacing.js';
import './rules/indent.js';
import './rules/key-spacing.js';
import './rules/keyword-spacing.js';
import './rules/lines-around-comment.js';
import './rules/lines-between-class-members.js';
import './rules/member-delimiter-style.js';
import './rules/no-extra-parens.js';
import './rules/no-extra-semi.js';
import './rules/object-curly-newline.js';
import './rules/object-curly-spacing.js';
import './rules/object-property-newline.js';
import './rules/padding-line-between-statements.js';
import './rules/quote-props.js';
import './rules/quotes.js';
import './rules/semi.js';
import './rules/space-before-blocks.js';
import './rules/space-before-function-paren.js';
import './rules/space-infix-ops.js';
import './rules/type-annotation-spacing.js';
var configs = require('./configs.js');
require('./utils.js');
require('eslint-visitor-keys');
require('espree');
require('./rules/block-spacing.js');
require('@typescript-eslint/utils');
require('@typescript-eslint/utils/ast-utils');
require('./rules/brace-style.js');
require('./rules/comma-dangle.js');
require('./rules/comma-spacing.js');
require('./rules/function-call-spacing.js');
require('./rules/indent.js');
require('./rules/key-spacing.js');
require('./rules/keyword-spacing.js');
require('./rules/lines-around-comment.js');
require('./rules/lines-between-class-members.js');
require('./rules/member-delimiter-style.js');
require('./rules/no-extra-parens.js');
require('./rules/no-extra-semi.js');
require('./rules/object-curly-newline.js');
require('./rules/object-curly-spacing.js');
require('./rules/object-property-newline.js');
require('./rules/padding-line-between-statements.js');
require('./rules/quote-props.js');
require('./rules/quotes.js');
require('./rules/semi.js');
require('./rules/space-before-blocks.js');
require('./rules/space-before-function-paren.js');
require('./rules/space-infix-ops.js');
require('./rules/type-annotation-spacing.js');
var index = Object.assign(plugin, { configs });
var index = Object.assign(configs.plugin, { configs: configs.configs });
module.exports = index;
export { index as default };

30

dist/rules/block-spacing.js

@@ -1,10 +0,8 @@

'use strict';
import { c as createRule, i as isTokenOnSameLine, a as castRuleModule } from '../utils.js';
import { AST_TOKEN_TYPES } from '@typescript-eslint/utils';
import { isTokenOnSameLine as isTokenOnSameLine$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "block-spacing",

@@ -41,3 +39,3 @@ package: "js",

function isValid(left, right) {
return !utils.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetween(left, right) === always;
return !isTokenOnSameLine(left, right) || sourceCode.isSpaceBetween(left, right) === always;
}

@@ -109,4 +107,4 @@ function checkSpacingInsideBraces(node) {

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var blockSpacing = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var blockSpacing = createRule({
name: "block-spacing",

@@ -132,7 +130,7 @@ package: "ts",

return sourceCode.getFirstToken(node, {
filter: (token) => token.type === utils$1.AST_TOKEN_TYPES.Punctuator && token.value === "{"
filter: (token) => token.type === AST_TOKEN_TYPES.Punctuator && token.value === "{"
});
}
function isValid(left, right) {
return !astUtils.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetween(left, right) === always;
return !isTokenOnSameLine$1(left, right) || sourceCode.isSpaceBetween(left, right) === always;
}

@@ -148,6 +146,6 @@ function checkSpacingInsideBraces(node) {

});
if (openBrace.type !== utils$1.AST_TOKEN_TYPES.Punctuator || openBrace.value !== "{" || closeBrace.type !== utils$1.AST_TOKEN_TYPES.Punctuator || closeBrace.value !== "}" || firstToken === closeBrace) {
if (openBrace.type !== AST_TOKEN_TYPES.Punctuator || openBrace.value !== "{" || closeBrace.type !== AST_TOKEN_TYPES.Punctuator || closeBrace.value !== "}" || firstToken === closeBrace) {
return;
}
if (!always && firstToken.type === utils$1.AST_TOKEN_TYPES.Line)
if (!always && firstToken.type === AST_TOKEN_TYPES.Line)
return;

@@ -214,2 +212,2 @@ if (!isValid(openBrace, firstToken)) {

module.exports = blockSpacing;
export { blockSpacing as default };

46

dist/rules/brace-style.js

@@ -1,9 +0,7 @@

'use strict';
import { c as createRule, S as STATEMENT_LIST_PARENTS, i as isTokenOnSameLine, a as castRuleModule } from '../utils.js';
import { isTokenOnSameLine as isTokenOnSameLine$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "brace-style",

@@ -57,4 +55,4 @@ package: "js",

const tokenBeforeClosingCurly = sourceCode.getTokenBefore(closingCurly);
const singleLineException = params.allowSingleLine && utils.isTokenOnSameLine(openingCurly, closingCurly);
if (style !== "allman" && !utils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly)) {
const singleLineException = params.allowSingleLine && isTokenOnSameLine(openingCurly, closingCurly);
if (style !== "allman" && !isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly)) {
context.report({

@@ -69,3 +67,3 @@ node: openingCurly,

}
if (style === "allman" && utils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly) && !singleLineException) {
if (style === "allman" && isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurly) && !singleLineException) {
context.report({

@@ -77,3 +75,3 @@ node: openingCurly,

}
if (utils.isTokenOnSameLine(openingCurly, tokenAfterOpeningCurly) && tokenAfterOpeningCurly !== closingCurly && !singleLineException) {
if (isTokenOnSameLine(openingCurly, tokenAfterOpeningCurly) && tokenAfterOpeningCurly !== closingCurly && !singleLineException) {
context.report({

@@ -85,3 +83,3 @@ node: openingCurly,

}
if (tokenBeforeClosingCurly !== openingCurly && !singleLineException && utils.isTokenOnSameLine(tokenBeforeClosingCurly, closingCurly)) {
if (tokenBeforeClosingCurly !== openingCurly && !singleLineException && isTokenOnSameLine(tokenBeforeClosingCurly, closingCurly)) {
context.report({

@@ -96,3 +94,3 @@ node: closingCurly,

const keywordToken = sourceCode.getTokenAfter(curlyToken);
if (style === "1tbs" && !utils.isTokenOnSameLine(curlyToken, keywordToken)) {
if (style === "1tbs" && !isTokenOnSameLine(curlyToken, keywordToken)) {
context.report({

@@ -104,3 +102,3 @@ node: curlyToken,

}
if (style !== "1tbs" && utils.isTokenOnSameLine(curlyToken, keywordToken)) {
if (style !== "1tbs" && isTokenOnSameLine(curlyToken, keywordToken)) {
context.report({

@@ -115,3 +113,3 @@ node: curlyToken,

BlockStatement(node) {
if (!utils.STATEMENT_LIST_PARENTS.has(node.parent.type))
if (!STATEMENT_LIST_PARENTS.has(node.parent.type))
validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));

@@ -149,4 +147,4 @@ },

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var braceStyle = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var braceStyle = createRule({
name: "brace-style",

@@ -168,3 +166,3 @@ package: "ts",

style,
{ allowSingleLine } = { allowSingleLine: false }
{ allowSingleLine } = { }
] = context.options;

@@ -175,3 +173,3 @@ const isAllmanStyle = style === "allman";

function validateCurlyPair(openingCurlyToken, closingCurlyToken) {
if (allowSingleLine && astUtils.isTokenOnSameLine(openingCurlyToken, closingCurlyToken)) {
if (allowSingleLine && isTokenOnSameLine$1(openingCurlyToken, closingCurlyToken)) {
return;

@@ -182,3 +180,3 @@ }

const tokenAfterOpeningCurly = sourceCode.getTokenAfter(openingCurlyToken);
if (!isAllmanStyle && !astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurlyToken)) {
if (!isAllmanStyle && !isTokenOnSameLine$1(tokenBeforeOpeningCurly, openingCurlyToken)) {
context.report({

@@ -202,3 +200,3 @@ node: openingCurlyToken,

}
if (isAllmanStyle && astUtils.isTokenOnSameLine(tokenBeforeOpeningCurly, openingCurlyToken)) {
if (isAllmanStyle && isTokenOnSameLine$1(tokenBeforeOpeningCurly, openingCurlyToken)) {
context.report({

@@ -210,3 +208,3 @@ node: openingCurlyToken,

}
if (astUtils.isTokenOnSameLine(openingCurlyToken, tokenAfterOpeningCurly) && tokenAfterOpeningCurly !== closingCurlyToken) {
if (isTokenOnSameLine$1(openingCurlyToken, tokenAfterOpeningCurly) && tokenAfterOpeningCurly !== closingCurlyToken) {
context.report({

@@ -218,3 +216,3 @@ node: openingCurlyToken,

}
if (astUtils.isTokenOnSameLine(tokenBeforeClosingCurly, closingCurlyToken) && tokenBeforeClosingCurly !== openingCurlyToken) {
if (isTokenOnSameLine$1(tokenBeforeClosingCurly, closingCurlyToken) && tokenBeforeClosingCurly !== openingCurlyToken) {
context.report({

@@ -246,2 +244,2 @@ node: closingCurlyToken,

module.exports = braceStyle;
export { braceStyle as default };

38

dist/rules/comma-dangle.js

@@ -1,9 +0,7 @@

'use strict';
import { c as createRule, b as isCommaToken, g as getNextLocation, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import { isCommaToken as isCommaToken$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
const DEFAULT_OPTIONS = Object.freeze({

@@ -47,3 +45,3 @@ arrays: "never",

}
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "comma-dangle",

@@ -131,3 +129,3 @@ package: "js",

const nextToken = sourceCode.getTokenAfter(lastItem);
if (utils.isCommaToken(nextToken))
if (isCommaToken(nextToken))
return nextToken;

@@ -155,3 +153,3 @@ return sourceCode.getLastToken(lastItem);

const trailingToken = getTrailingToken(info);
if (trailingToken && utils.isCommaToken(trailingToken)) {
if (trailingToken && isCommaToken(trailingToken)) {
context.report({

@@ -187,3 +185,3 @@ node: lastItem,

start: trailingToken.loc.end,
end: utils.getNextLocation(sourceCode, trailingToken.loc.end)
end: getNextLocation(sourceCode, trailingToken.loc.end)
},

@@ -310,3 +308,3 @@ messageId: "missing",

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
const OPTION_VALUE_SCHEME = [

@@ -333,3 +331,3 @@ "always-multiline",

}
var commaDangle = utils.createRule({
var commaDangle = createRule({
name: "comma-dangle",

@@ -405,7 +403,7 @@ package: "ts",

switch (node.type) {
case utils$1.AST_NODE_TYPES.TSEnumDeclaration:
case AST_NODE_TYPES.TSEnumDeclaration:
return last(node.body?.members || node.members);
case utils$1.AST_NODE_TYPES.TSTypeParameterDeclaration:
case AST_NODE_TYPES.TSTypeParameterDeclaration:
return last(node.params);
case utils$1.AST_NODE_TYPES.TSTupleType:
case AST_NODE_TYPES.TSTupleType:
return last(node.elementTypes);

@@ -427,7 +425,7 @@ default:

function forbidComma(node) {
if (isTSX && node.type === utils$1.AST_NODE_TYPES.TSTypeParameterDeclaration && node.params.length === 1)
if (isTSX && node.type === AST_NODE_TYPES.TSTypeParameterDeclaration && node.params.length === 1)
return;
const last2 = getLastItem(node);
const trailing = getTrailingToken(node);
if (last2 && trailing && astUtils.isCommaToken(trailing)) {
if (last2 && trailing && isCommaToken$1(trailing)) {
context.report({

@@ -445,3 +443,3 @@ node,

const trailing = getTrailingToken(node);
if (last2 && trailing && !astUtils.isCommaToken(trailing)) {
if (last2 && trailing && !isCommaToken$1(trailing)) {
context.report({

@@ -475,2 +473,2 @@ node,

module.exports = commaDangle;
export { commaDangle as default };

30

dist/rules/comma-spacing.js

@@ -1,10 +0,8 @@

'use strict';
import { c as createRule } from '../utils.js';
import { AST_TOKEN_TYPES } from '@typescript-eslint/utils';
import { isCommaToken, isTokenOnSameLine, isClosingParenToken, isClosingBracketToken, isClosingBraceToken } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
var commaSpacing = utils.createRule({
var commaSpacing = createRule({
name: "comma-spacing",

@@ -56,3 +54,3 @@ package: "ts",

token = sourceCode.getTokenAfter(previousToken);
if (token && astUtils.isCommaToken(token))
if (token && isCommaToken(token))
ignoredTokens.add(token);

@@ -70,3 +68,3 @@ } else {

const afterToken = sourceCode.getTokenAfter(param);
if (afterToken && astUtils.isCommaToken(afterToken))
if (afterToken && isCommaToken(afterToken))
ignoredTokens.add(afterToken);

@@ -76,3 +74,3 @@ }

function validateCommaSpacing(commaToken, prevToken, nextToken) {
if (prevToken && astUtils.isTokenOnSameLine(prevToken, commaToken) && spaceBefore !== sourceCode.isSpaceBetween(prevToken, commaToken)) {
if (prevToken && isTokenOnSameLine(prevToken, commaToken) && spaceBefore !== sourceCode.isSpaceBetween(prevToken, commaToken)) {
context.report({

@@ -90,3 +88,3 @@ node: commaToken,

}
if (nextToken && astUtils.isTokenOnSameLine(commaToken, nextToken) && !astUtils.isClosingParenToken(nextToken) && !astUtils.isClosingBracketToken(nextToken) && !astUtils.isClosingBraceToken(nextToken) && !(!spaceAfter && nextToken.type === utils$1.AST_TOKEN_TYPES.Line) && spaceAfter !== sourceCode.isSpaceBetween(commaToken, nextToken)) {
if (nextToken && isTokenOnSameLine(commaToken, nextToken) && !isClosingParenToken(nextToken) && !isClosingBracketToken(nextToken) && !isClosingBraceToken(nextToken) && !(!spaceAfter && nextToken.type === AST_TOKEN_TYPES.Line) && spaceAfter !== sourceCode.isSpaceBetween(commaToken, nextToken)) {
context.report({

@@ -111,3 +109,3 @@ node: commaToken,

tokensAndComments.forEach((token, i) => {
if (!astUtils.isCommaToken(token))
if (!isCommaToken(token))
return;

@@ -118,4 +116,4 @@ const prevToken = tokensAndComments[i - 1];

token,
astUtils.isCommaToken(prevToken) || ignoredTokens.has(token) ? null : prevToken,
nextToken && astUtils.isCommaToken(nextToken) || ignoredTokens.has(token) ? null : nextToken
isCommaToken(prevToken) || ignoredTokens.has(token) ? null : prevToken,
nextToken && isCommaToken(nextToken) || ignoredTokens.has(token) ? null : nextToken
);

@@ -128,2 +126,2 @@ });

module.exports = commaSpacing;
export { commaSpacing as default };

24

dist/rules/function-call-spacing.js

@@ -1,9 +0,7 @@

'use strict';
import { c as createRule } from '../utils.js';
import { isOpeningParenToken, isNotOptionalChainPunctuator, isOptionalCallExpression, LINEBREAK_MATCHER } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
var functionCallSpacing = utils.createRule({
var functionCallSpacing = createRule({
name: "function-call-spacing",

@@ -76,6 +74,6 @@ package: "ts",

function checkSpacing(node, leftToken, rightToken) {
const isOptionalCall = astUtils.isOptionalCallExpression(node);
const isOptionalCall = isOptionalCallExpression(node);
const textBetweenTokens = text.slice(leftToken.range[1], rightToken.range[0]).replace(/\/\*.*?\*\//gu, "");
const hasWhitespace = /\s/u.test(textBetweenTokens);
const hasNewline = hasWhitespace && astUtils.LINEBREAK_MATCHER.test(textBetweenTokens);
const hasNewline = hasWhitespace && LINEBREAK_MATCHER.test(textBetweenTokens);
if (option === "never") {

@@ -127,3 +125,3 @@ if (hasWhitespace) {

if (!allowNewlines) {
const GLOBAL_LINEBREAK_MATCHER = new RegExp(astUtils.LINEBREAK_MATCHER.source, "g");
const GLOBAL_LINEBREAK_MATCHER = new RegExp(LINEBREAK_MATCHER.source, "g");
text2 = text2.replaceAll(GLOBAL_LINEBREAK_MATCHER, " ");

@@ -181,3 +179,3 @@ }

closingParenToken,
astUtils.isOpeningParenToken
isOpeningParenToken
);

@@ -189,3 +187,3 @@ if (!openingParenToken || openingParenToken.range[1] >= node.range[1]) {

openingParenToken,
astUtils.isNotOptionalChainPunctuator
isNotOptionalChainPunctuator
);

@@ -203,2 +201,2 @@ checkSpacing(node, lastCalleeToken, openingParenToken);

module.exports = functionCallSpacing;
export { functionCallSpacing as default };

48

dist/rules/key-spacing.js

@@ -1,9 +0,7 @@

'use strict';
import { c as createRule, q as isColonToken, v as getStaticPropertyName, w as getStringLength, m as isOpeningBraceToken, s as isClosingBraceToken, L as LINEBREAK_MATCHER, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import { isClosingBracketToken, isColonToken as isColonToken$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
const listeningNodes = [

@@ -20,3 +18,3 @@ "ObjectExpression",

function containsLineTerminator(str) {
return utils.LINEBREAK_MATCHER.test(str);
return LINEBREAK_MATCHER.test(str);
}

@@ -30,4 +28,4 @@ function last(arr) {

function isSingleLineImportAttributes(node, sourceCode) {
const openingBrace = sourceCode.getTokenBefore(node.attributes[0], utils.isOpeningBraceToken);
const closingBrace = sourceCode.getTokenAfter(node.attributes[node.attributes.length - 1], utils.isClosingBraceToken);
const openingBrace = sourceCode.getTokenBefore(node.attributes[0], isOpeningBraceToken);
const closingBrace = sourceCode.getTokenAfter(node.attributes[node.attributes.length - 1], isClosingBraceToken);
return closingBrace.loc.end.line === openingBrace.loc.start.line;

@@ -86,3 +84,3 @@ }

}
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "key-spacing",

@@ -296,3 +294,3 @@ package: "js",

function getNextColon(node) {
return sourceCode.getTokenAfter(node, utils.isColonToken);
return sourceCode.getTokenAfter(node, isColonToken);
}

@@ -326,3 +324,3 @@ function getLastTokenBeforeColon(node) {

return sourceCode.getText().slice(key.range[0], key.range[1]);
return utils.getStaticPropertyName(property);
return getStaticPropertyName(property);
}

@@ -384,3 +382,3 @@ function report(property, side, whitespace, expected, mode) {

const endToken = getLastTokenBeforeColon(property.key);
return utils.getStringLength(sourceCode.getText().slice(startToken.range[0], endToken.range[1]));
return getStringLength(sourceCode.getText().slice(startToken.range[0], endToken.range[1]));
}

@@ -516,5 +514,5 @@ function getPropertyWhitespace(property) {

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
const baseSchema = Array.isArray(baseRule.meta.schema) ? baseRule.meta.schema[0] : baseRule.meta.schema;
var keySpacing = utils.createRule({
var keySpacing = createRule({
name: "key-spacing",

@@ -540,3 +538,3 @@ package: "ts",

const line = position.line - 1;
return utils.getStringLength(
return getStringLength(
sourceCode.lines.at(line).slice(0, position.column)

@@ -546,7 +544,7 @@ );

function getLastTokenBeforeColon(node) {
const colonToken = sourceCode.getTokenAfter(node, astUtils.isColonToken);
const colonToken = sourceCode.getTokenAfter(node, isColonToken$1);
return sourceCode.getTokenBefore(colonToken);
}
function isKeyTypeNode(node) {
return (node.type === utils$1.AST_NODE_TYPES.TSPropertySignature || node.type === utils$1.AST_NODE_TYPES.TSIndexSignature || node.type === utils$1.AST_NODE_TYPES.PropertyDefinition) && !!node.typeAnnotation;
return (node.type === AST_NODE_TYPES.TSPropertySignature || node.type === AST_NODE_TYPES.TSIndexSignature || node.type === AST_NODE_TYPES.PropertyDefinition) && !!node.typeAnnotation;
}

@@ -557,3 +555,3 @@ function isApplicable(node) {

function getKeyText(node) {
if (node.type !== utils$1.AST_NODE_TYPES.TSIndexSignature)
if (node.type !== AST_NODE_TYPES.TSIndexSignature)
return sourceCode.getText(node.key);

@@ -565,3 +563,3 @@ const code = sourceCode.getText(node);

node.parameters.at(-1),
astUtils.isClosingBracketToken
isClosingBracketToken
).range[1] - node.range[0]

@@ -572,3 +570,3 @@ );

return getLastTokenBeforeColon(
node.type !== utils$1.AST_NODE_TYPES.TSIndexSignature ? node.key : node.parameters.at(-1)
node.type !== AST_NODE_TYPES.TSIndexSignature ? node.key : node.parameters.at(-1)
).loc.end;

@@ -712,3 +710,3 @@ }

const isSingleLine = body.loc.start.line === body.loc.end.line;
const members = body.type === utils$1.AST_NODE_TYPES.TSTypeLiteral ? body.members : body.body;
const members = body.type === AST_NODE_TYPES.TSTypeLiteral ? body.members : body.body;
let alignGroups = [];

@@ -723,3 +721,3 @@ let unalignedElements = [];

if (prevAlignedNode !== prevNode)
prevAlignedNode = undefined;
prevAlignedNode = void 0;
if (prevAlignedNode && continuesAlignGroup(prevAlignedNode, node)) {

@@ -760,2 +758,2 @@ currentAlignGroup.push(node);

module.exports = keySpacing;
export { keySpacing as default };

52

dist/rules/keyword-spacing.js

@@ -1,8 +0,6 @@

'use strict';
import { K as KEYWORDS_JS, c as createRule, l as isNotOpeningParenToken, i as isTokenOnSameLine, x as isKeywordToken, a as castRuleModule, y as deepMerge, z as nullThrows, N as NullThrowsReasons } from '../utils.js';
import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
require('eslint-visitor-keys');
require('espree');
const PREV_TOKEN = /^[)\]}>]$/u;

@@ -15,3 +13,3 @@ const NEXT_TOKEN = /^(?:[([{<~!]|\+\+?|--?)$/u;

const CHECK_TYPE = /^(?:JSXElement|RegularExpression|String|Template|PrivateIdentifier)$/u;
const KEYS = utils.KEYWORDS_JS.concat(["as", "async", "await", "from", "get", "let", "of", "satisfies", "set", "yield"]);
const KEYS = KEYWORDS_JS.concat(["as", "async", "await", "from", "get", "let", "of", "satisfies", "set", "yield"]);
(function() {

@@ -30,3 +28,3 @@ KEYS.sort();

}
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "keyword-spacing",

@@ -77,3 +75,3 @@ package: "js",

const prevToken = sourceCode.getTokenBefore(token);
if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && utils.isTokenOnSameLine(prevToken, token) && !sourceCode.isSpaceBetween(prevToken, token)) {
if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && isTokenOnSameLine(prevToken, token) && !sourceCode.isSpaceBetween(prevToken, token)) {
context.report({

@@ -92,3 +90,3 @@ loc: token.loc,

const prevToken = sourceCode.getTokenBefore(token);
if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && utils.isTokenOnSameLine(prevToken, token) && sourceCode.isSpaceBetween(prevToken, token)) {
if (prevToken && (CHECK_TYPE.test(prevToken.type) || pattern.test(prevToken.value)) && !isOpenParenOfTemplate(prevToken) && !tokensToIgnore.has(prevToken) && isTokenOnSameLine(prevToken, token) && sourceCode.isSpaceBetween(prevToken, token)) {
context.report({

@@ -107,3 +105,3 @@ loc: { start: prevToken.loc.end, end: token.loc.start },

const nextToken = sourceCode.getTokenAfter(token);
if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && utils.isTokenOnSameLine(token, nextToken) && !sourceCode.isSpaceBetween(token, nextToken)) {
if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && isTokenOnSameLine(token, nextToken) && !sourceCode.isSpaceBetween(token, nextToken)) {
context.report({

@@ -122,3 +120,3 @@ loc: token.loc,

const nextToken = sourceCode.getTokenAfter(token);
if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && utils.isTokenOnSameLine(token, nextToken) && sourceCode.isSpaceBetween(token, nextToken)) {
if (nextToken && (CHECK_TYPE.test(nextToken.type) || pattern.test(nextToken.value)) && !isCloseParenOfTemplate(nextToken) && !tokensToIgnore.has(nextToken) && isTokenOnSameLine(token, nextToken) && sourceCode.isSpaceBetween(token, nextToken)) {
context.report({

@@ -183,3 +181,3 @@ loc: { start: token.loc.end, end: nextToken.loc.start },

if (node) {
const token = sourceCode.getTokenBefore(node, utils.isKeywordToken);
const token = sourceCode.getTokenBefore(node, isKeywordToken);
if (token)

@@ -214,3 +212,3 @@ checkSpacingAround(token);

checkSpacingAroundFirstToken(node);
const inToken = sourceCode.getTokenBefore(node.right, utils.isNotOpeningParenToken);
const inToken = sourceCode.getTokenBefore(node.right, isNotOpeningParenToken);
const previousToken = sourceCode.getTokenBefore(inToken);

@@ -228,3 +226,3 @@ if (previousToken.type !== "PrivateIdentifier")

}
const ofToken = sourceCode.getTokenBefore(node.right, utils.isNotOpeningParenToken);
const ofToken = sourceCode.getTokenBefore(node.right, isNotOpeningParenToken);
const previousToken = sourceCode.getTokenBefore(ofToken);

@@ -342,3 +340,3 @@ if (previousToken.type !== "PrivateIdentifier")

"BinaryExpression[operator='>']": function(node) {
const operatorToken = sourceCode.getTokenBefore(node.right, utils.isNotOpeningParenToken);
const operatorToken = sourceCode.getTokenBefore(node.right, isNotOpeningParenToken);
tokensToIgnore.add(operatorToken);

@@ -350,5 +348,5 @@ }

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
const baseSchema = Array.isArray(baseRule.meta.schema) ? baseRule.meta.schema[0] : baseRule.meta.schema;
const schema = utils.deepMerge(
const schema = deepMerge(
baseSchema,

@@ -365,3 +363,3 @@ {

);
var keywordSpacing = utils.createRule({
var keywordSpacing = createRule({
name: "keyword-spacing",

@@ -387,3 +385,3 @@ package: "ts",

TSAsExpression(node) {
const asToken = utils.nullThrows(
const asToken = nullThrows(
sourceCode.getTokenAfter(

@@ -393,6 +391,6 @@ node.expression,

),
utils.NullThrowsReasons.MissingToken("as", node.type)
NullThrowsReasons.MissingToken("as", node.type)
);
const oldTokenType = asToken.type;
asToken.type = utils$1.AST_TOKEN_TYPES.Keyword;
asToken.type = AST_TOKEN_TYPES.Keyword;
baseRules.DebuggerStatement(asToken);

@@ -403,3 +401,3 @@ asToken.type = oldTokenType;

TSSatisfiesExpression(node) {
const satisfiesToken = utils.nullThrows(
const satisfiesToken = nullThrows(
sourceCode.getTokenAfter(

@@ -409,6 +407,6 @@ node.expression,

),
utils.NullThrowsReasons.MissingToken("satisfies", node.type)
NullThrowsReasons.MissingToken("satisfies", node.type)
);
const oldTokenType = satisfiesToken.type;
satisfiesToken.type = utils$1.AST_TOKEN_TYPES.Keyword;
satisfiesToken.type = AST_TOKEN_TYPES.Keyword;
baseRules.DebuggerStatement(satisfiesToken);

@@ -421,3 +419,3 @@ satisfiesToken.type = oldTokenType;

const punctuatorToken = sourceCode.getTokenAfter(typeToken);
if (node.specifiers?.[0]?.type === utils$1.AST_NODE_TYPES.ImportDefaultSpecifier)
if (node.specifiers?.[0]?.type === AST_NODE_TYPES.ImportDefaultSpecifier)
return;

@@ -453,2 +451,2 @@ const spacesBetweenTypeAndPunctuator = punctuatorToken.range[0] - typeToken.range[1];

module.exports = keywordSpacing;
export { keywordSpacing as default };

70

dist/rules/lines-around-comment.js

@@ -1,9 +0,7 @@

'use strict';
import { c as createRule, C as COMMENTS_IGNORE_PATTERN$1, e as isCommentToken, i as isTokenOnSameLine, m as isOpeningBraceToken, a as castRuleModule } from '../utils.js';
import { AST_TOKEN_TYPES, AST_NODE_TYPES } from '@typescript-eslint/utils';
import { isCommentToken as isCommentToken$1, isTokenOnSameLine as isTokenOnSameLine$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
function getEmptyLineNums$1(lines) {

@@ -25,3 +23,3 @@ const emptyLines = lines.map((line, i) => ({

}
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "lines-around-comment",

@@ -103,3 +101,3 @@ package: "js",

const ignorePattern = options.ignorePattern;
const defaultIgnoreRegExp = utils.COMMENTS_IGNORE_PATTERN;
const defaultIgnoreRegExp = COMMENTS_IGNORE_PATTERN$1;
const customIgnoreRegExp = ignorePattern && new RegExp(ignorePattern, "u");

@@ -119,4 +117,4 @@ const applyDefaultIgnorePatterns = options.applyDefaultIgnorePatterns !== false;

currentToken = sourceCode.getTokenBefore(currentToken, { includeComments: true });
while (currentToken && utils.isCommentToken(currentToken));
if (currentToken && utils.isTokenOnSameLine(currentToken, token))
while (currentToken && isCommentToken(currentToken));
if (currentToken && isTokenOnSameLine(currentToken, token))
return true;

@@ -126,4 +124,4 @@ currentToken = token;

currentToken = sourceCode.getTokenAfter(currentToken, { includeComments: true });
while (currentToken && utils.isCommentToken(currentToken));
if (currentToken && utils.isTokenOnSameLine(token, currentToken))
while (currentToken && isCommentToken(currentToken));
if (currentToken && isTokenOnSameLine(token, currentToken))
return true;

@@ -151,3 +149,3 @@ return false;

parentStartNodeOrToken = sourceCode.getTokenAfter(parent.discriminant, {
filter: utils.isOpeningBraceToken
filter: isOpeningBraceToken
});

@@ -215,3 +213,3 @@ }

const nextTokenOrComment = sourceCode.getTokenAfter(token, { includeComments: true });
if (!exceptionStartAllowed && before && !commentAndEmptyLines.has(prevLineNum) && !(utils.isCommentToken(previousTokenOrComment) && utils.isTokenOnSameLine(previousTokenOrComment, token))) {
if (!exceptionStartAllowed && before && !commentAndEmptyLines.has(prevLineNum) && !(isCommentToken(previousTokenOrComment) && isTokenOnSameLine(previousTokenOrComment, token))) {
const lineStart = token.range[0] - token.loc.start.column;

@@ -227,3 +225,3 @@ const range = [lineStart, lineStart];

}
if (!exceptionEndAllowed && after && !commentAndEmptyLines.has(nextLineNum) && !(utils.isCommentToken(nextTokenOrComment) && utils.isTokenOnSameLine(token, nextTokenOrComment))) {
if (!exceptionEndAllowed && after && !commentAndEmptyLines.has(nextLineNum) && !(isCommentToken(nextTokenOrComment) && isTokenOnSameLine(token, nextTokenOrComment))) {
context.report({

@@ -269,3 +267,3 @@ node: token,

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;

@@ -288,3 +286,3 @@ function getEmptyLineNums(lines) {

}
var linesAroundComment = utils.createRule({
var linesAroundComment = createRule({
name: "lines-around-comment",

@@ -405,4 +403,4 @@ package: "ts",

});
} while (currentToken && astUtils.isCommentToken(currentToken));
if (currentToken && astUtils.isTokenOnSameLine(currentToken, token))
} while (currentToken && isCommentToken$1(currentToken));
if (currentToken && isTokenOnSameLine$1(currentToken, token))
return true;

@@ -414,4 +412,4 @@ currentToken = token;

});
} while (currentToken && astUtils.isCommentToken(currentToken));
if (currentToken && astUtils.isTokenOnSameLine(token, currentToken))
} while (currentToken && isCommentToken$1(currentToken));
if (currentToken && isTokenOnSameLine$1(token, currentToken))
return true;

@@ -440,24 +438,24 @@ return false;

function isCommentAtInterfaceStart(token) {
return isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSInterfaceBody);
return isCommentAtParentStart(token, AST_NODE_TYPES.TSInterfaceBody);
}
function isCommentAtInterfaceEnd(token) {
return isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSInterfaceBody);
return isCommentAtParentEnd(token, AST_NODE_TYPES.TSInterfaceBody);
}
function isCommentAtTypeStart(token) {
return isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSTypeLiteral);
return isCommentAtParentStart(token, AST_NODE_TYPES.TSTypeLiteral);
}
function isCommentAtTypeEnd(token) {
return isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSTypeLiteral);
return isCommentAtParentEnd(token, AST_NODE_TYPES.TSTypeLiteral);
}
function isCommentAtEnumStart(token) {
return isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSEnumBody) || isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSEnumDeclaration);
return isCommentAtParentStart(token, AST_NODE_TYPES.TSEnumBody) || isCommentAtParentStart(token, AST_NODE_TYPES.TSEnumDeclaration);
}
function isCommentAtEnumEnd(token) {
return isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSEnumBody) || isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSEnumDeclaration);
return isCommentAtParentEnd(token, AST_NODE_TYPES.TSEnumBody) || isCommentAtParentEnd(token, AST_NODE_TYPES.TSEnumDeclaration);
}
function isCommentAtModuleStart(token) {
return isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSModuleBlock);
return isCommentAtParentStart(token, AST_NODE_TYPES.TSModuleBlock);
}
function isCommentAtModuleEnd(token) {
return isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSModuleBlock);
return isCommentAtParentEnd(token, AST_NODE_TYPES.TSModuleBlock);
}

@@ -495,3 +493,3 @@ function isCommentNearTSConstruct(token) {

});
if (!exceptionStartAllowed && before && !commentAndEmptyLines.has(prevLineNum) && !(astUtils.isCommentToken(previousTokenOrComment) && astUtils.isTokenOnSameLine(previousTokenOrComment, token))) {
if (!exceptionStartAllowed && before && !commentAndEmptyLines.has(prevLineNum) && !(isCommentToken$1(previousTokenOrComment) && isTokenOnSameLine$1(previousTokenOrComment, token))) {
const lineStart = token.range[0] - token.loc.start.column;

@@ -507,3 +505,3 @@ const range = [lineStart, lineStart];

}
if (!exceptionEndAllowed && after && !commentAndEmptyLines.has(nextLineNum) && !(astUtils.isCommentToken(nextTokenOrComment) && astUtils.isTokenOnSameLine(token, nextTokenOrComment))) {
if (!exceptionEndAllowed && after && !commentAndEmptyLines.has(nextLineNum) && !(isCommentToken$1(nextTokenOrComment) && isTokenOnSameLine$1(token, nextTokenOrComment))) {
context.report({

@@ -520,3 +518,3 @@ node: token,

if ("node" in descriptor) {
if (descriptor.node.type === utils$1.AST_TOKEN_TYPES.Line || descriptor.node.type === utils$1.AST_TOKEN_TYPES.Block) {
if (descriptor.node.type === AST_TOKEN_TYPES.Line || descriptor.node.type === AST_TOKEN_TYPES.Block) {
if (isCommentNearTSConstruct(descriptor.node))

@@ -544,3 +542,3 @@ return;

comments.forEach((token) => {
if (token.type === utils$1.AST_TOKEN_TYPES.Line) {
if (token.type === AST_TOKEN_TYPES.Line) {
if (options.beforeLineComment || options.afterLineComment) {

@@ -552,3 +550,3 @@ checkForEmptyLine(token, {

}
} else if (token.type === utils$1.AST_TOKEN_TYPES.Block) {
} else if (token.type === AST_TOKEN_TYPES.Block) {
if (options.beforeBlockComment || options.afterBlockComment) {

@@ -567,2 +565,2 @@ checkForEmptyLine(token, {

module.exports = linesAroundComment;
export { linesAroundComment as default };

26

dist/rules/lines-between-class-members.js

@@ -1,8 +0,6 @@

'use strict';
import { c as createRule, i as isTokenOnSameLine, f as isSemicolonToken, y as deepMerge, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
require('eslint-visitor-keys');
require('espree');
const ClassMemberTypes = {

@@ -13,3 +11,3 @@ "*": { test: () => true },

};
var _baseRule = utils.createRule(
var _baseRule = createRule(
{

@@ -80,3 +78,3 @@ name: "lines-between-class-members",

const nextToken = sourceCode.getFirstToken(nextNode);
const isSemicolonLessStyle = utils.isSemicolonToken(lastToken) && !utils.isTokenOnSameLine(prevToken, lastToken) && utils.isTokenOnSameLine(lastToken, nextToken);
const isSemicolonLessStyle = isSemicolonToken(lastToken) && !isTokenOnSameLine(prevToken, lastToken) && isTokenOnSameLine(lastToken, nextToken);
return isSemicolonLessStyle ? { curLast: prevToken, nextFirst: lastToken } : { curLast: lastToken, nextFirst: nextToken };

@@ -117,3 +115,3 @@ }

const { curLast, nextFirst } = getBoundaryTokens(body[i], body[i + 1]);
const isMulti = !utils.isTokenOnSameLine(curFirst, curLast);
const isMulti = !isTokenOnSameLine(curFirst, curLast);
const skip = !isMulti && options[1].exceptAfterSingleLine;

@@ -154,5 +152,5 @@ const beforePadding = findLastConsecutiveTokenAfter(curLast, nextFirst, 1);

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
const schema = Object.values(
utils.deepMerge(
deepMerge(
{ ...baseRule.meta.schema },

@@ -171,3 +169,3 @@ {

);
var linesBetweenClassMembers = utils.createRule({
var linesBetweenClassMembers = createRule({
name: "lines-between-class-members",

@@ -196,3 +194,3 @@ package: "ts",

function isOverload(node) {
return (node.type === utils$1.AST_NODE_TYPES.TSAbstractMethodDefinition || node.type === utils$1.AST_NODE_TYPES.MethodDefinition) && node.value.type === utils$1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
return (node.type === AST_NODE_TYPES.TSAbstractMethodDefinition || node.type === AST_NODE_TYPES.MethodDefinition) && node.value.type === AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
}

@@ -208,2 +206,2 @@ return {

module.exports = linesBetweenClassMembers;
export { linesBetweenClassMembers as default };

22

dist/rules/member-delimiter-style.js

@@ -1,8 +0,6 @@

'use strict';
import { c as createRule, y as deepMerge } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
require('eslint-visitor-keys');
require('espree');
function isLastTokenEndOfLine(token, line) {

@@ -65,3 +63,3 @@ const positionInLine = token.loc.start.column;

};
var memberDelimiterStyle = utils.createRule({
var memberDelimiterStyle = createRule({
name: "member-delimiter-style",

@@ -137,7 +135,7 @@ package: "ts",

const overrides = baseOptions.overrides ?? {};
const interfaceOptions = utils.deepMerge(
const interfaceOptions = deepMerge(
baseOptions,
overrides.interface
);
const typeLiteralOptions = utils.deepMerge(
const typeLiteralOptions = deepMerge(
baseOptions,

@@ -216,3 +214,3 @@ overrides.typeLiteral

function checkMemberSeparatorStyle(node) {
const members = node.type === utils$1.AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
const members = node.type === AST_NODE_TYPES.TSInterfaceBody ? node.body : node.members;
let isSingleLine = node.loc.start.line === node.loc.end.line;

@@ -224,3 +222,3 @@ if (options.multilineDetection === "last-member" && !isSingleLine && members.length > 0) {

}
const typeOpts = node.type === utils$1.AST_NODE_TYPES.TSInterfaceBody ? interfaceOptions : typeLiteralOptions;
const typeOpts = node.type === AST_NODE_TYPES.TSInterfaceBody ? interfaceOptions : typeLiteralOptions;
const opts = isSingleLine ? { ...typeOpts.singleline, type: "single-line" } : { ...typeOpts.multiline, type: "multi-line" };

@@ -238,2 +236,2 @@ members.forEach((member, index) => {

module.exports = memberDelimiterStyle;
export { memberDelimiterStyle as default };

164

dist/rules/no-extra-parens.js

@@ -1,10 +0,8 @@

'use strict';
import { c as createRule, A as getPrecedence, B as isDecimalInteger, l as isNotOpeningParenToken, n as isOpeningBracketToken, r as isNotClosingParenToken, h as isOpeningParenToken, m as isOpeningBraceToken, D as skipChainExpression, v as getStaticPropertyName, E as isParenthesized, k as isClosingParenToken, F as isMixedLogicalAndCoalesceExpressions, G as canTokensBeAdjacent, H as isTopLevelExpressionStatement, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import { isTypeAssertion, isOpeningParenToken as isOpeningParenToken$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "no-extra-parens",

@@ -68,3 +66,3 @@ package: "js",

const tokensToIgnore = /* @__PURE__ */ new WeakSet();
const precedence = utils.getPrecedence;
const precedence = getPrecedence;
const ALL_NODES = context.options[0] !== "functions";

@@ -86,7 +84,7 @@ const EXCEPT_COND_ASSIGN = ALL_NODES && context.options[1] && context.options[1].conditionalAssign === false;

function isImmediateFunctionPrototypeMethodCall(node) {
const callNode = utils.skipChainExpression(node);
const callNode = skipChainExpression(node);
if (callNode.type !== "CallExpression")
return false;
const callee = utils.skipChainExpression(callNode.callee);
return callee.type === "MemberExpression" && callee.object.type === "FunctionExpression" && ["call", "apply"].includes(utils.getStaticPropertyName(callee));
const callee = skipChainExpression(callNode.callee);
return callee.type === "MemberExpression" && callee.object.type === "FunctionExpression" && ["call", "apply"].includes(getStaticPropertyName(callee));
}

@@ -115,6 +113,6 @@ function ruleApplies(node) {

function isParenthesised(node) {
return utils.isParenthesized(node, sourceCode, 1);
return isParenthesized(node, sourceCode, 1);
}
function isParenthesisedTwice(node) {
return utils.isParenthesized(node, sourceCode, 2);
return isParenthesized(node, sourceCode, 2);
}

@@ -150,3 +148,3 @@ function hasExcessParens(node) {

return newExpression.arguments.length > 0 || // The expression should end with its own parens, e.g., new new foo() is not a new expression with parens
utils.isOpeningParenToken(penultimateToken) && utils.isClosingParenToken(lastToken) && newExpression.callee.range[1] < newExpression.range[1];
isOpeningParenToken(penultimateToken) && isClosingParenToken(lastToken) && newExpression.callee.range[1] < newExpression.range[1];
}

@@ -182,3 +180,3 @@ function containsAssignment(node) {

const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParenToken, { includeComments: true });
return tokenBeforeLeftParen && tokenBeforeLeftParen.range[1] === leftParenToken.range[0] && leftParenToken.range[1] === tokenAfterLeftParen.range[0] && !utils.canTokensBeAdjacent(tokenBeforeLeftParen, tokenAfterLeftParen);
return tokenBeforeLeftParen && tokenBeforeLeftParen.range[1] === leftParenToken.range[0] && leftParenToken.range[1] === tokenAfterLeftParen.range[0] && !canTokensBeAdjacent(tokenBeforeLeftParen, tokenAfterLeftParen);
}

@@ -190,6 +188,6 @@ function requiresTrailingSpace(node) {

const tokenBeforeRightParen = sourceCode.getLastToken(node);
return rightParenToken && tokenAfterRightParen && !sourceCode.isSpaceBetween(rightParenToken, tokenAfterRightParen) && !utils.canTokensBeAdjacent(tokenBeforeRightParen, tokenAfterRightParen);
return rightParenToken && tokenAfterRightParen && !sourceCode.isSpaceBetween(rightParenToken, tokenAfterRightParen) && !canTokensBeAdjacent(tokenBeforeRightParen, tokenAfterRightParen);
}
function isIIFE(node) {
const maybeCallNode = utils.skipChainExpression(node);
const maybeCallNode = skipChainExpression(node);
return maybeCallNode.type === "CallExpression" && maybeCallNode.callee.type === "FunctionExpression";

@@ -205,3 +203,3 @@ }

return true;
return !utils.isTopLevelExpressionStatement(node.parent);
return !isTopLevelExpressionStatement(node.parent);
}

@@ -277,3 +275,3 @@ function report(node) {

if (!shouldSkipLeft && hasExcessParens(node.left)) {
if (!(["AwaitExpression", "UnaryExpression"].includes(node.left.type) && isExponentiation) && !utils.isMixedLogicalAndCoalesceExpressions(node.left, node) && (leftPrecedence > prec || leftPrecedence === prec && !isExponentiation) || isParenthesisedTwice(node.left)) {
if (!(["AwaitExpression", "UnaryExpression"].includes(node.left.type) && isExponentiation) && !isMixedLogicalAndCoalesceExpressions(node.left, node) && (leftPrecedence > prec || leftPrecedence === prec && !isExponentiation) || isParenthesisedTwice(node.left)) {
report(node.left);

@@ -283,3 +281,3 @@ }

if (!shouldSkipRight && hasExcessParens(node.right)) {
if (!utils.isMixedLogicalAndCoalesceExpressions(node.right, node) && (rightPrecedence > prec || rightPrecedence === prec && isExponentiation) || isParenthesisedTwice(node.right)) {
if (!isMixedLogicalAndCoalesceExpressions(node.right, node) && (rightPrecedence > prec || rightPrecedence === prec && isExponentiation) || isParenthesisedTwice(node.right)) {
report(node.right);

@@ -302,6 +300,6 @@ }

const firstToken = isParenthesised(node) ? sourceCode.getTokenBefore(node) : sourceCode.getFirstToken(node);
const secondToken = sourceCode.getTokenAfter(firstToken, utils.isNotOpeningParenToken);
const secondToken = sourceCode.getTokenAfter(firstToken, isNotOpeningParenToken);
const thirdToken = secondToken ? sourceCode.getTokenAfter(secondToken) : null;
const tokenAfterClosingParens = secondToken ? sourceCode.getTokenAfter(secondToken, utils.isNotClosingParenToken) : null;
if (utils.isOpeningParenToken(firstToken) && (utils.isOpeningBraceToken(secondToken) || secondToken.type === "Keyword" && (secondToken.value === "function" || secondToken.value === "class" || secondToken.value === "let" && tokenAfterClosingParens && (utils.isOpeningBracketToken(tokenAfterClosingParens) || tokenAfterClosingParens.type === "Identifier")) || secondToken && secondToken.type === "Identifier" && secondToken.value === "async" && thirdToken && thirdToken.type === "Keyword" && thirdToken.value === "function")) {
const tokenAfterClosingParens = secondToken ? sourceCode.getTokenAfter(secondToken, isNotClosingParenToken) : null;
if (isOpeningParenToken(firstToken) && (isOpeningBraceToken(secondToken) || secondToken.type === "Keyword" && (secondToken.value === "function" || secondToken.value === "class" || secondToken.value === "let" && tokenAfterClosingParens && (isOpeningBracketToken(tokenAfterClosingParens) || tokenAfterClosingParens.type === "Identifier")) || secondToken && secondToken.type === "Identifier" && secondToken.value === "async" && thirdToken && thirdToken.type === "Keyword" && thirdToken.value === "function")) {
tokensToIgnore.add(secondToken);

@@ -318,3 +316,3 @@ }

currentNode = currentNode.parent;
if (currentNode === null || currentNode === undefined)
if (currentNode === null || currentNode === void 0)
throw new Error("Nodes are not in the ancestor-descendant relationship.");

@@ -405,5 +403,5 @@ path.push(currentNode);

if (node.body.type !== "BlockStatement") {
const firstBodyToken = sourceCode.getFirstToken(node.body, utils.isNotOpeningParenToken);
const firstBodyToken = sourceCode.getFirstToken(node.body, isNotOpeningParenToken);
const tokenBeforeFirst = sourceCode.getTokenBefore(firstBodyToken);
if (utils.isOpeningParenToken(tokenBeforeFirst) && utils.isOpeningBraceToken(firstBodyToken))
if (isOpeningParenToken(tokenBeforeFirst) && isOpeningBraceToken(firstBodyToken))
tokensToIgnore.add(firstBodyToken);

@@ -449,5 +447,5 @@ if (hasExcessParensWithPrecedence(node.body, PRECEDENCE_OF_ASSIGNMENT_EXPR))

if (node.left.type !== "VariableDeclaration") {
const firstLeftToken = sourceCode.getFirstToken(node.left, utils.isNotOpeningParenToken);
if (firstLeftToken.value === "let" && utils.isOpeningBracketToken(
sourceCode.getTokenAfter(firstLeftToken, utils.isNotClosingParenToken)
const firstLeftToken = sourceCode.getFirstToken(node.left, isNotOpeningParenToken);
if (firstLeftToken.value === "let" && isOpeningBracketToken(
sourceCode.getTokenAfter(firstLeftToken, isNotClosingParenToken)
)) {

@@ -464,3 +462,3 @@ tokensToIgnore.add(firstLeftToken);

if (node.left.type !== "VariableDeclaration") {
const firstLeftToken = sourceCode.getFirstToken(node.left, utils.isNotOpeningParenToken);
const firstLeftToken = sourceCode.getFirstToken(node.left, isNotOpeningParenToken);
if (firstLeftToken.value === "let") {

@@ -482,5 +480,5 @@ tokensToIgnore.add(firstLeftToken);

if (node.init.type !== "VariableDeclaration") {
const firstToken = sourceCode.getFirstToken(node.init, utils.isNotOpeningParenToken);
if (firstToken.value === "let" && utils.isOpeningBracketToken(
sourceCode.getTokenAfter(firstToken, utils.isNotClosingParenToken)
const firstToken = sourceCode.getFirstToken(node.init, isNotOpeningParenToken);
if (firstToken.value === "let" && isOpeningBracketToken(
sourceCode.getTokenAfter(firstToken, isNotClosingParenToken)
)) {

@@ -543,3 +541,3 @@ tokensToIgnore.add(firstToken);

const nodeObjHasExcessParens = shouldAllowWrapOnce ? hasDoubleExcessParens(node.object) : hasExcessParens(node.object) && !(isImmediateFunctionPrototypeMethodCall(node.parent) && "callee" in node.parent && node.parent.callee === node && IGNORE_FUNCTION_PROTOTYPE_METHODS);
if (nodeObjHasExcessParens && precedence(node.object) >= precedence(node) && (node.computed || !(utils.isDecimalInteger(node.object) || node.object.type === "Literal" && "regex" in node.object && node.object.regex))) {
if (nodeObjHasExcessParens && precedence(node.object) >= precedence(node) && (node.computed || !(isDecimalInteger(node.object) || node.object.type === "Literal" && "regex" in node.object && node.object.regex))) {
report(node.object);

@@ -676,4 +674,4 @@ }

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var noExtraParens = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var noExtraParens = createRule({
name: "no-extra-parens",

@@ -697,4 +695,4 @@ package: "ts",

const rule = rules.BinaryExpression;
const isLeftTypeAssertion = astUtils.isTypeAssertion(node.left);
const isRightTypeAssertion = astUtils.isTypeAssertion(node.right);
const isLeftTypeAssertion = isTypeAssertion(node.left);
const isRightTypeAssertion = isTypeAssertion(node.right);
if (isLeftTypeAssertion && isRightTypeAssertion)

@@ -707,3 +705,3 @@ return;

...node.left,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -717,3 +715,3 @@ });

...node.right,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -726,3 +724,3 @@ });

const rule = rules.CallExpression;
if (astUtils.isTypeAssertion(node.callee)) {
if (isTypeAssertion(node.callee)) {
return rule({

@@ -732,7 +730,7 @@ ...node,

...node.callee,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}
});
}
if (node.typeArguments && node.arguments.length === 1 && sourceCode.getTokenAfter(node.callee, astUtils.isOpeningParenToken) !== sourceCode.getTokenBefore(node.arguments[0], astUtils.isOpeningParenToken)) {
if (node.typeArguments && node.arguments.length === 1 && sourceCode.getTokenAfter(node.callee, isOpeningParenToken$1) !== sourceCode.getTokenBefore(node.arguments[0], isOpeningParenToken$1)) {
return rule({

@@ -743,3 +741,3 @@ ...node,

...node.arguments[0],
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -753,3 +751,3 @@ ]

const rule = rules.UnaryExpression;
if (astUtils.isTypeAssertion(node.argument)) {
if (isTypeAssertion(node.argument)) {
return rule({

@@ -759,3 +757,3 @@ ...node,

...node.argument,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -771,3 +769,3 @@ });

elements: node.elements.map(
(element) => astUtils.isTypeAssertion(element) ? { ...element, type: utils$1.AST_NODE_TYPES.FunctionExpression } : element
(element) => isTypeAssertion(element) ? { ...element, type: AST_NODE_TYPES.FunctionExpression } : element
)

@@ -777,3 +775,3 @@ });

ArrowFunctionExpression(node) {
if (!astUtils.isTypeAssertion(node.body))
if (!isTypeAssertion(node.body))
return rules.ArrowFunctionExpression(node);

@@ -783,3 +781,3 @@ },

AwaitExpression(node) {
if (astUtils.isTypeAssertion(node.argument)) {
if (isTypeAssertion(node.argument)) {
return rules.AwaitExpression({

@@ -789,3 +787,3 @@ ...node,

...node.argument,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -799,3 +797,3 @@ });

ClassDeclaration(node) {
if (node.superClass?.type === utils$1.AST_NODE_TYPES.TSAsExpression) {
if (node.superClass?.type === AST_NODE_TYPES.TSAsExpression) {
return rules.ClassDeclaration({

@@ -805,3 +803,3 @@ ...node,

...node.superClass,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -813,3 +811,3 @@ });

ClassExpression(node) {
if (node.superClass?.type === utils$1.AST_NODE_TYPES.TSAsExpression) {
if (node.superClass?.type === AST_NODE_TYPES.TSAsExpression) {
return rules.ClassExpression({

@@ -819,3 +817,3 @@ ...node,

...node.superClass,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -827,3 +825,3 @@ });

ConditionalExpression(node) {
if (astUtils.isTypeAssertion(node.test)) {
if (isTypeAssertion(node.test)) {
return rules.ConditionalExpression({

@@ -833,7 +831,7 @@ ...node,

...node.test,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}
});
}
if (astUtils.isTypeAssertion(node.consequent)) {
if (isTypeAssertion(node.consequent)) {
return rules.ConditionalExpression({

@@ -843,7 +841,7 @@ ...node,

...node.consequent,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}
});
}
if (astUtils.isTypeAssertion(node.alternate)) {
if (isTypeAssertion(node.alternate)) {
return rules.ConditionalExpression({

@@ -853,3 +851,3 @@ ...node,

...node.alternate,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -863,3 +861,3 @@ });

ForStatement(node) {
if (node.init && astUtils.isTypeAssertion(node.init)) {
if (node.init && isTypeAssertion(node.init)) {
return rules.ForStatement({

@@ -870,3 +868,3 @@ ...node,

}
if (node.test && astUtils.isTypeAssertion(node.test)) {
if (node.test && isTypeAssertion(node.test)) {
return rules.ForStatement({

@@ -877,3 +875,3 @@ ...node,

}
if (node.update && astUtils.isTypeAssertion(node.update)) {
if (node.update && isTypeAssertion(node.update)) {
return rules.ForStatement({

@@ -887,3 +885,3 @@ ...node,

"ForStatement > *.init:exit": function(node) {
if (!astUtils.isTypeAssertion(node))
if (!isTypeAssertion(node))
return rules["ForStatement > *.init:exit"](node);

@@ -894,3 +892,3 @@ },

MemberExpression(node) {
if (astUtils.isTypeAssertion(node.object)) {
if (isTypeAssertion(node.object)) {
return rules.MemberExpression({

@@ -900,7 +898,7 @@ ...node,

...node.object,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}
});
}
if (astUtils.isTypeAssertion(node.property)) {
if (isTypeAssertion(node.property)) {
return rules.MemberExpression({

@@ -910,3 +908,3 @@ ...node,

...node.property,
type: utils$1.AST_NODE_TYPES.FunctionExpression
type: AST_NODE_TYPES.FunctionExpression
}

@@ -922,7 +920,7 @@ });

SpreadElement(node) {
if (!astUtils.isTypeAssertion(node.argument))
if (!isTypeAssertion(node.argument))
return rules.SpreadElement(node);
},
SwitchCase(node) {
if (node.test && !astUtils.isTypeAssertion(node.test))
if (node.test && !isTypeAssertion(node.test))
return rules.SwitchCase(node);

@@ -932,3 +930,3 @@ },

ThrowStatement(node) {
if (node.argument && !astUtils.isTypeAssertion(node.argument))
if (node.argument && !isTypeAssertion(node.argument))
return rules.ThrowStatement(node);

@@ -938,3 +936,3 @@ },

UpdateExpression(node) {
if (astUtils.isTypeAssertion(node.argument)) {
if (isTypeAssertion(node.argument)) {
return unaryUpdateExpression(node);

@@ -946,9 +944,9 @@ }

VariableDeclarator(node) {
if (astUtils.isTypeAssertion(node.init)) {
if (isTypeAssertion(node.init)) {
return rules.VariableDeclarator({
...node,
type: utils$1.AST_NODE_TYPES.VariableDeclarator,
type: AST_NODE_TYPES.VariableDeclarator,
init: {
...node.init,
type: utils$1.AST_NODE_TYPES.FunctionExpression
type: AST_NODE_TYPES.FunctionExpression
}

@@ -962,7 +960,7 @@ });

YieldExpression(node) {
if (node.argument && !astUtils.isTypeAssertion(node.argument))
if (node.argument && !isTypeAssertion(node.argument))
return rules.YieldExpression(node);
},
ForInStatement(node) {
if (astUtils.isTypeAssertion(node.right)) {
if (isTypeAssertion(node.right)) {
return;

@@ -973,9 +971,9 @@ }

ForOfStatement(node) {
if (astUtils.isTypeAssertion(node.right)) {
if (isTypeAssertion(node.right)) {
return rules.ForOfStatement({
...node,
type: utils$1.AST_NODE_TYPES.ForOfStatement,
type: AST_NODE_TYPES.ForOfStatement,
right: {
...node.right,
type: utils$1.AST_NODE_TYPES.SequenceExpression
type: AST_NODE_TYPES.SequenceExpression
}

@@ -989,3 +987,3 @@ });

...node,
type: utils$1.AST_NODE_TYPES.FunctionExpression
type: AST_NODE_TYPES.FunctionExpression
});

@@ -998,2 +996,2 @@ }

module.exports = noExtraParens;
export { noExtraParens as default };

24

dist/rules/no-extra-semi.js

@@ -1,8 +0,6 @@

'use strict';
import { c as createRule, I as FixTracker, s as isClosingBraceToken, f as isSemicolonToken, H as isTopLevelExpressionStatement, a as castRuleModule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "no-extra-semi",

@@ -28,3 +26,3 @@ package: "js",

const stringNode = sourceCode.getNodeByRangeIndex(nextToken.range[0]);
return !utils.isTopLevelExpressionStatement(stringNode.parent);
return !isTopLevelExpressionStatement(stringNode.parent);
}

@@ -35,8 +33,8 @@ function report(nodeOrToken) {

messageId: "unexpected",
fix: isFixable(nodeOrToken) ? (fixer) => new utils.FixTracker(fixer, context.sourceCode).retainSurroundingTokens(nodeOrToken).remove(nodeOrToken) : null
fix: isFixable(nodeOrToken) ? (fixer) => new FixTracker(fixer, context.sourceCode).retainSurroundingTokens(nodeOrToken).remove(nodeOrToken) : null
});
}
function checkForPartOfClassBody(firstToken) {
for (let token = firstToken; token.type === "Punctuator" && !utils.isClosingBraceToken(token); token = sourceCode.getTokenAfter(token)) {
if (utils.isSemicolonToken(token))
for (let token = firstToken; token.type === "Punctuator" && !isClosingBraceToken(token); token = sourceCode.getTokenAfter(token)) {
if (isSemicolonToken(token))
report(token);

@@ -83,4 +81,4 @@ }

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var noExtraSemi = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var noExtraSemi = createRule({
name: "no-extra-semi",

@@ -110,2 +108,2 @@ package: "ts",

module.exports = noExtraSemi;
export { noExtraSemi as default };

28

dist/rules/object-curly-newline.js

@@ -1,7 +0,5 @@

'use strict';
import { c as createRule, e as isCommentToken, i as isTokenOnSameLine, a as castRuleModule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
const OPTION_VALUE = {

@@ -84,3 +82,3 @@ oneOf: [

}
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "object-curly-newline",

@@ -138,8 +136,8 @@ package: "js",

const needsLineBreaks = areLineBreaksRequired(node, options, first, last);
const hasCommentsFirstToken = utils.isCommentToken(first);
const hasCommentsLastToken = utils.isCommentToken(last);
const hasCommentsFirstToken = isCommentToken(first);
const hasCommentsLastToken = isCommentToken(last);
first = sourceCode.getTokenAfter(openBrace);
last = sourceCode.getTokenBefore(closeBrace);
if (needsLineBreaks) {
if (utils.isTokenOnSameLine(openBrace, first)) {
if (isTokenOnSameLine(openBrace, first)) {
context.report({

@@ -156,3 +154,3 @@ messageId: "expectedLinebreakAfterOpeningBrace",

}
if (utils.isTokenOnSameLine(last, closeBrace)) {
if (isTokenOnSameLine(last, closeBrace)) {
context.report({

@@ -171,4 +169,4 @@ messageId: "expectedLinebreakBeforeClosingBrace",

const consistent = options.consistent;
const hasLineBreakBetweenOpenBraceAndFirst = !utils.isTokenOnSameLine(openBrace, first);
const hasLineBreakBetweenCloseBraceAndLast = !utils.isTokenOnSameLine(last, closeBrace);
const hasLineBreakBetweenOpenBraceAndFirst = !isTokenOnSameLine(openBrace, first);
const hasLineBreakBetweenCloseBraceAndLast = !isTokenOnSameLine(last, closeBrace);
if (!consistent && hasLineBreakBetweenOpenBraceAndFirst || consistent && hasLineBreakBetweenOpenBraceAndFirst && !hasLineBreakBetweenCloseBraceAndLast) {

@@ -217,5 +215,5 @@ context.report({

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
const defaultOptionValue = { multiline: false, minProperties: Number.POSITIVE_INFINITY, consistent: true };
var objectCurlyNewline = utils.createRule({
var objectCurlyNewline = createRule({
name: "object-curly-newline",

@@ -245,2 +243,2 @@ package: "ts",

module.exports = objectCurlyNewline;
export { objectCurlyNewline as default };

54

dist/rules/object-curly-spacing.js

@@ -1,10 +0,8 @@

'use strict';
import { c as createRule, J as isNotCommaToken, i as isTokenOnSameLine, o as isClosingBracketToken, s as isClosingBraceToken, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
import { isTokenOnSameLine as isTokenOnSameLine$1, isClosingBracketToken as isClosingBracketToken$1, isClosingBraceToken as isClosingBraceToken$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
var _baseRule = utils.createRule(
var _baseRule = createRule(
{

@@ -110,3 +108,3 @@ name: "object-curly-spacing",

function validateBraceSpacing(node, first, second, penultimate, last) {
if (utils.isTokenOnSameLine(first, second)) {
if (isTokenOnSameLine(first, second)) {
const firstSpaced = sourceCode.isSpaceBetween(first, second);

@@ -118,4 +116,4 @@ if (options.spaced && !firstSpaced)

}
if (utils.isTokenOnSameLine(penultimate, last)) {
const shouldCheckPenultimate = options.arraysInObjectsException && utils.isClosingBracketToken(penultimate) || options.objectsInObjectsException && utils.isClosingBraceToken(penultimate);
if (isTokenOnSameLine(penultimate, last)) {
const shouldCheckPenultimate = options.arraysInObjectsException && isClosingBracketToken(penultimate) || options.objectsInObjectsException && isClosingBraceToken(penultimate);
const penultimateType = shouldCheckPenultimate && sourceCode.getNodeByRangeIndex(penultimate.range[0]).type;

@@ -132,3 +130,3 @@ const closingCurlyBraceMustBeSpaced = options.arraysInObjectsException && penultimateType === "ArrayExpression" || options.objectsInObjectsException && (penultimateType === "ObjectExpression" || penultimateType === "ObjectPattern") ? !options.spaced : options.spaced;

const lastProperty = node.properties[node.properties.length - 1];
return sourceCode.getTokenAfter(lastProperty, utils.isClosingBraceToken);
return sourceCode.getTokenAfter(lastProperty, isClosingBraceToken);
}

@@ -154,3 +152,3 @@ function checkForObject(node) {

const first = sourceCode.getTokenBefore(firstSpecifier);
const last = sourceCode.getTokenAfter(lastSpecifier, utils.isNotCommaToken);
const last = sourceCode.getTokenAfter(lastSpecifier, isNotCommaToken);
const second = sourceCode.getTokenAfter(first, { includeComments: true });

@@ -166,3 +164,3 @@ const penultimate = sourceCode.getTokenBefore(last, { includeComments: true });

const first = sourceCode.getTokenBefore(firstSpecifier);
const last = sourceCode.getTokenAfter(lastSpecifier, utils.isNotCommaToken);
const last = sourceCode.getTokenAfter(lastSpecifier, isNotCommaToken);
const second = sourceCode.getTokenAfter(first, { includeComments: true });

@@ -186,4 +184,4 @@ const penultimate = sourceCode.getTokenBefore(last, { includeComments: true });

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var objectCurlySpacing = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var objectCurlySpacing = createRule({
name: "object-curly-spacing",

@@ -265,3 +263,3 @@ package: "ts",

function validateBraceSpacing(node, first, second, penultimate, last) {
if (astUtils.isTokenOnSameLine(first, second)) {
if (isTokenOnSameLine$1(first, second)) {
const firstSpaced = sourceCode.isSpaceBetween(first, second);

@@ -272,17 +270,17 @@ const secondType = sourceCode.getNodeByRangeIndex(

const openingCurlyBraceMustBeSpaced = options.arraysInObjectsException && [
utils$1.AST_NODE_TYPES.TSMappedType,
utils$1.AST_NODE_TYPES.TSIndexSignature
AST_NODE_TYPES.TSMappedType,
AST_NODE_TYPES.TSIndexSignature
].includes(secondType) ? !options.spaced : options.spaced;
if (openingCurlyBraceMustBeSpaced && !firstSpaced)
reportRequiredBeginningSpace(node, first);
if (!openingCurlyBraceMustBeSpaced && firstSpaced && second.type !== utils$1.AST_TOKEN_TYPES.Line) {
if (!openingCurlyBraceMustBeSpaced && firstSpaced && second.type !== AST_TOKEN_TYPES.Line) {
reportNoBeginningSpace(node, first);
}
}
if (astUtils.isTokenOnSameLine(penultimate, last)) {
const shouldCheckPenultimate = options.arraysInObjectsException && astUtils.isClosingBracketToken(penultimate) || options.objectsInObjectsException && astUtils.isClosingBraceToken(penultimate);
const penultimateType = shouldCheckPenultimate ? sourceCode.getNodeByRangeIndex(penultimate.range[0]).type : undefined;
const closingCurlyBraceMustBeSpaced = options.arraysInObjectsException && penultimateType === utils$1.AST_NODE_TYPES.TSTupleType || options.objectsInObjectsException && penultimateType !== undefined && [
utils$1.AST_NODE_TYPES.TSMappedType,
utils$1.AST_NODE_TYPES.TSTypeLiteral
if (isTokenOnSameLine$1(penultimate, last)) {
const shouldCheckPenultimate = options.arraysInObjectsException && isClosingBracketToken$1(penultimate) || options.objectsInObjectsException && isClosingBraceToken$1(penultimate);
const penultimateType = shouldCheckPenultimate ? sourceCode.getNodeByRangeIndex(penultimate.range[0]).type : void 0;
const closingCurlyBraceMustBeSpaced = options.arraysInObjectsException && penultimateType === AST_NODE_TYPES.TSTupleType || options.objectsInObjectsException && penultimateType !== void 0 && [
AST_NODE_TYPES.TSMappedType,
AST_NODE_TYPES.TSTypeLiteral
].includes(penultimateType) ? !options.spaced : options.spaced;

@@ -298,3 +296,3 @@ const lastSpaced = sourceCode.isSpaceBetween(penultimate, last);

const lastProperty = node.members[node.members.length - 1];
return sourceCode.getTokenAfter(lastProperty, astUtils.isClosingBraceToken);
return sourceCode.getTokenAfter(lastProperty, isClosingBraceToken$1);
}

@@ -332,2 +330,2 @@ const rules = baseRule.create(context);

module.exports = objectCurlySpacing;
export { objectCurlySpacing as default };

16

dist/rules/object-property-newline.js

@@ -1,8 +0,6 @@

'use strict';
import { c as createRule, a as castRuleModule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "object-property-newline",

@@ -76,4 +74,4 @@ package: "js",

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var objectPropertyNewline = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var objectPropertyNewline = createRule({
name: "object-property-newline",

@@ -115,2 +113,2 @@ package: "ts",

module.exports = objectPropertyNewline;
export { objectPropertyNewline as default };

144

dist/rules/padding-line-between-statements.js

@@ -1,9 +0,7 @@

'use strict';
import { c as createRule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import { isTokenOnSameLine, isSemicolonToken, isNotSemicolonToken, isClosingBraceToken, isFunction, isParenthesized } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils$1 = require('../utils.js');
var utils = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u;

@@ -47,14 +45,14 @@ const CJS_IMPORT = /^require\(/u;

function skipChainExpression(node) {
return node && node.type === utils.AST_NODE_TYPES.ChainExpression ? node.expression : node;
return node && node.type === AST_NODE_TYPES.ChainExpression ? node.expression : node;
}
function isIIFEStatement(node) {
if (node.type === utils.AST_NODE_TYPES.ExpressionStatement) {
if (node.type === AST_NODE_TYPES.ExpressionStatement) {
let expression = skipChainExpression(node.expression);
if (expression.type === utils.AST_NODE_TYPES.UnaryExpression)
if (expression.type === AST_NODE_TYPES.UnaryExpression)
expression = skipChainExpression(expression.argument);
if (expression.type === utils.AST_NODE_TYPES.CallExpression) {
if (expression.type === AST_NODE_TYPES.CallExpression) {
let node2 = expression.callee;
while (node2.type === utils.AST_NODE_TYPES.SequenceExpression)
while (node2.type === AST_NODE_TYPES.SequenceExpression)
node2 = node2.expressions[node2.expressions.length - 1];
return astUtils.isFunction(node2);
return isFunction(node2);
}

@@ -65,9 +63,9 @@ }

function isCJSRequire(node) {
if (node.type === utils.AST_NODE_TYPES.VariableDeclaration) {
if (node.type === AST_NODE_TYPES.VariableDeclaration) {
const declaration = node.declarations[0];
if (declaration?.init) {
let call = declaration?.init;
while (call.type === utils.AST_NODE_TYPES.MemberExpression)
while (call.type === AST_NODE_TYPES.MemberExpression)
call = call.object;
if (call.type === utils.AST_NODE_TYPES.CallExpression && call.callee.type === utils.AST_NODE_TYPES.Identifier) {
if (call.type === AST_NODE_TYPES.CallExpression && call.callee.type === AST_NODE_TYPES.Identifier) {
return call.callee.name === "require";

@@ -80,3 +78,3 @@ }

function isBlockLikeStatement(node, sourceCode) {
if (node.type === utils.AST_NODE_TYPES.DoWhileStatement && node.body.type === utils.AST_NODE_TYPES.BlockStatement) {
if (node.type === AST_NODE_TYPES.DoWhileStatement && node.body.type === AST_NODE_TYPES.BlockStatement) {
return true;

@@ -86,8 +84,8 @@ }

return true;
const lastToken = sourceCode.getLastToken(node, astUtils.isNotSemicolonToken);
const belongingNode = lastToken && astUtils.isClosingBraceToken(lastToken) ? sourceCode.getNodeByRangeIndex(lastToken.range[0]) : null;
return !!belongingNode && (belongingNode.type === utils.AST_NODE_TYPES.BlockStatement || belongingNode.type === utils.AST_NODE_TYPES.SwitchStatement);
const lastToken = sourceCode.getLastToken(node, isNotSemicolonToken);
const belongingNode = lastToken && isClosingBraceToken(lastToken) ? sourceCode.getNodeByRangeIndex(lastToken.range[0]) : null;
return !!belongingNode && (belongingNode.type === AST_NODE_TYPES.BlockStatement || belongingNode.type === AST_NODE_TYPES.SwitchStatement);
}
function isDirective(node, sourceCode) {
return node.type === utils.AST_NODE_TYPES.ExpressionStatement && (node.parent?.type === utils.AST_NODE_TYPES.Program || node.parent?.type === utils.AST_NODE_TYPES.BlockStatement && astUtils.isFunction(node.parent.parent)) && node.expression.type === utils.AST_NODE_TYPES.Literal && typeof node.expression.value === "string" && !astUtils.isParenthesized(node.expression, sourceCode);
return node.type === AST_NODE_TYPES.ExpressionStatement && (node.parent?.type === AST_NODE_TYPES.Program || node.parent?.type === AST_NODE_TYPES.BlockStatement && isFunction(node.parent.parent)) && node.expression.type === AST_NODE_TYPES.Literal && typeof node.expression.value === "string" && !isParenthesized(node.expression, sourceCode);
}

@@ -107,10 +105,10 @@ function isDirectivePrologue(node, sourceCode) {

function isCJSExport(node) {
if (node.type === utils.AST_NODE_TYPES.ExpressionStatement) {
if (node.type === AST_NODE_TYPES.ExpressionStatement) {
const expression = node.expression;
if (expression.type === utils.AST_NODE_TYPES.AssignmentExpression) {
if (expression.type === AST_NODE_TYPES.AssignmentExpression) {
let left = expression.left;
if (left.type === utils.AST_NODE_TYPES.MemberExpression) {
while (left.object.type === utils.AST_NODE_TYPES.MemberExpression)
if (left.type === AST_NODE_TYPES.MemberExpression) {
while (left.object.type === AST_NODE_TYPES.MemberExpression)
left = left.object;
return left.object.type === utils.AST_NODE_TYPES.Identifier && (left.object.name === "exports" || left.object.name === "module" && left.property.type === utils.AST_NODE_TYPES.Identifier && left.property.name === "exports");
return left.object.type === AST_NODE_TYPES.Identifier && (left.object.name === "exports" || left.object.name === "module" && left.property.type === AST_NODE_TYPES.Identifier && left.property.name === "exports");
}

@@ -122,3 +120,3 @@ }

function isExpression(node, sourceCode) {
return node.type === utils.AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode);
return node.type === AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode);
}

@@ -129,3 +127,3 @@ function getActualLastToken(node, sourceCode) {

const nextToken = sourceCode.getTokenAfter(semiToken);
const isSemicolonLessStyle = prevToken && nextToken && prevToken.range[0] >= node.range[0] && astUtils.isSemicolonToken(semiToken) && semiToken.loc.start.line !== prevToken.loc.end.line && semiToken.loc.end.line === nextToken.loc.start.line;
const isSemicolonLessStyle = prevToken && nextToken && prevToken.range[0] >= node.range[0] && isSemicolonToken(semiToken) && semiToken.loc.start.line !== prevToken.loc.end.line && semiToken.loc.end.line === nextToken.loc.start.line;
return isSemicolonLessStyle ? prevToken : semiToken;

@@ -188,3 +186,3 @@ }

filter(token) {
if (astUtils.isTokenOnSameLine(prevToken, token)) {
if (isTokenOnSameLine(prevToken, token)) {
prevToken = token;

@@ -196,3 +194,3 @@ return false;

}) || nextNode;
const insertText = astUtils.isTokenOnSameLine(prevToken, nextToken) ? "\n\n" : "\n";
const insertText = isTokenOnSameLine(prevToken, nextToken) ? "\n\n" : "\n";
return fixer.insertTextAfter(prevToken, insertText);

@@ -219,3 +217,3 @@ }

"multiline-expression": {
test: (node, sourceCode) => node.loc.start.line !== node.loc.end.line && node.type === utils.AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode)
test: (node, sourceCode) => node.loc.start.line !== node.loc.end.line && node.type === AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode)
},

@@ -230,22 +228,22 @@ "multiline-const": newMultilineKeywordTester("const"),

"singleline-var": newSinglelineKeywordTester("var"),
"block": newNodeTypeTester(utils.AST_NODE_TYPES.BlockStatement),
"empty": newNodeTypeTester(utils.AST_NODE_TYPES.EmptyStatement),
"function": newNodeTypeTester(utils.AST_NODE_TYPES.FunctionDeclaration),
"ts-method": newNodeTypeTester(utils.AST_NODE_TYPES.TSMethodSignature),
"break": newKeywordTester(utils.AST_NODE_TYPES.BreakStatement, "break"),
"case": newKeywordTester(utils.AST_NODE_TYPES.SwitchCase, "case"),
"class": newKeywordTester(utils.AST_NODE_TYPES.ClassDeclaration, "class"),
"const": newKeywordTester(utils.AST_NODE_TYPES.VariableDeclaration, "const"),
"continue": newKeywordTester(utils.AST_NODE_TYPES.ContinueStatement, "continue"),
"debugger": newKeywordTester(utils.AST_NODE_TYPES.DebuggerStatement, "debugger"),
"block": newNodeTypeTester(AST_NODE_TYPES.BlockStatement),
"empty": newNodeTypeTester(AST_NODE_TYPES.EmptyStatement),
"function": newNodeTypeTester(AST_NODE_TYPES.FunctionDeclaration),
"ts-method": newNodeTypeTester(AST_NODE_TYPES.TSMethodSignature),
"break": newKeywordTester(AST_NODE_TYPES.BreakStatement, "break"),
"case": newKeywordTester(AST_NODE_TYPES.SwitchCase, "case"),
"class": newKeywordTester(AST_NODE_TYPES.ClassDeclaration, "class"),
"const": newKeywordTester(AST_NODE_TYPES.VariableDeclaration, "const"),
"continue": newKeywordTester(AST_NODE_TYPES.ContinueStatement, "continue"),
"debugger": newKeywordTester(AST_NODE_TYPES.DebuggerStatement, "debugger"),
"default": newKeywordTester(
[utils.AST_NODE_TYPES.SwitchCase, utils.AST_NODE_TYPES.ExportDefaultDeclaration],
[AST_NODE_TYPES.SwitchCase, AST_NODE_TYPES.ExportDefaultDeclaration],
"default"
),
"do": newKeywordTester(utils.AST_NODE_TYPES.DoWhileStatement, "do"),
"do": newKeywordTester(AST_NODE_TYPES.DoWhileStatement, "do"),
"export": newKeywordTester(
[
utils.AST_NODE_TYPES.ExportAllDeclaration,
utils.AST_NODE_TYPES.ExportDefaultDeclaration,
utils.AST_NODE_TYPES.ExportNamedDeclaration
AST_NODE_TYPES.ExportAllDeclaration,
AST_NODE_TYPES.ExportDefaultDeclaration,
AST_NODE_TYPES.ExportNamedDeclaration
],

@@ -256,21 +254,21 @@ "export"

[
utils.AST_NODE_TYPES.ForStatement,
utils.AST_NODE_TYPES.ForInStatement,
utils.AST_NODE_TYPES.ForOfStatement
AST_NODE_TYPES.ForStatement,
AST_NODE_TYPES.ForInStatement,
AST_NODE_TYPES.ForOfStatement
],
"for"
),
"if": newKeywordTester(utils.AST_NODE_TYPES.IfStatement, "if"),
"import": newKeywordTester(utils.AST_NODE_TYPES.ImportDeclaration, "import"),
"let": newKeywordTester(utils.AST_NODE_TYPES.VariableDeclaration, "let"),
"return": newKeywordTester(utils.AST_NODE_TYPES.ReturnStatement, "return"),
"switch": newKeywordTester(utils.AST_NODE_TYPES.SwitchStatement, "switch"),
"throw": newKeywordTester(utils.AST_NODE_TYPES.ThrowStatement, "throw"),
"try": newKeywordTester(utils.AST_NODE_TYPES.TryStatement, "try"),
"var": newKeywordTester(utils.AST_NODE_TYPES.VariableDeclaration, "var"),
"if": newKeywordTester(AST_NODE_TYPES.IfStatement, "if"),
"import": newKeywordTester(AST_NODE_TYPES.ImportDeclaration, "import"),
"let": newKeywordTester(AST_NODE_TYPES.VariableDeclaration, "let"),
"return": newKeywordTester(AST_NODE_TYPES.ReturnStatement, "return"),
"switch": newKeywordTester(AST_NODE_TYPES.SwitchStatement, "switch"),
"throw": newKeywordTester(AST_NODE_TYPES.ThrowStatement, "throw"),
"try": newKeywordTester(AST_NODE_TYPES.TryStatement, "try"),
"var": newKeywordTester(AST_NODE_TYPES.VariableDeclaration, "var"),
"while": newKeywordTester(
[utils.AST_NODE_TYPES.WhileStatement, utils.AST_NODE_TYPES.DoWhileStatement],
[AST_NODE_TYPES.WhileStatement, AST_NODE_TYPES.DoWhileStatement],
"while"
),
"with": newKeywordTester(utils.AST_NODE_TYPES.WithStatement, "with"),
"with": newKeywordTester(AST_NODE_TYPES.WithStatement, "with"),
"cjs-export": {

@@ -284,11 +282,11 @@ test: (node, sourceCode) => node.type === "ExpressionStatement" && node.expression.type === "AssignmentExpression" && CJS_EXPORT.test(sourceCode.getText(node.expression.left))

"enum": newKeywordTester(
utils.AST_NODE_TYPES.TSEnumDeclaration,
AST_NODE_TYPES.TSEnumDeclaration,
"enum"
),
"interface": newKeywordTester(
utils.AST_NODE_TYPES.TSInterfaceDeclaration,
AST_NODE_TYPES.TSInterfaceDeclaration,
"interface"
),
"type": newKeywordTester(
utils.AST_NODE_TYPES.TSTypeAliasDeclaration,
AST_NODE_TYPES.TSTypeAliasDeclaration,
"type"

@@ -300,3 +298,3 @@ ),

};
var paddingLineBetweenStatements = utils$1.createRule({
var paddingLineBetweenStatements = createRule({
name: "padding-line-between-statements",

@@ -372,3 +370,3 @@ package: "ts",

let innerStatementNode = node;
while (innerStatementNode.type === utils.AST_NODE_TYPES.LabeledStatement)
while (innerStatementNode.type === AST_NODE_TYPES.LabeledStatement)
innerStatementNode = innerStatementNode.body;

@@ -405,10 +403,10 @@ if (Array.isArray(type))

if (!node.parent || ![
utils.AST_NODE_TYPES.BlockStatement,
utils.AST_NODE_TYPES.Program,
utils.AST_NODE_TYPES.StaticBlock,
utils.AST_NODE_TYPES.SwitchCase,
utils.AST_NODE_TYPES.SwitchStatement,
utils.AST_NODE_TYPES.TSInterfaceBody,
utils.AST_NODE_TYPES.TSModuleBlock,
utils.AST_NODE_TYPES.TSTypeLiteral
AST_NODE_TYPES.BlockStatement,
AST_NODE_TYPES.Program,
AST_NODE_TYPES.StaticBlock,
AST_NODE_TYPES.SwitchCase,
AST_NODE_TYPES.SwitchStatement,
AST_NODE_TYPES.TSInterfaceBody,
AST_NODE_TYPES.TSModuleBlock,
AST_NODE_TYPES.TSTypeLiteral
].includes(node.parent.type)) {

@@ -455,2 +453,2 @@ return;

module.exports = paddingLineBetweenStatements;
export { paddingLineBetweenStatements as default };

38

dist/rules/quote-props.js

@@ -1,9 +0,7 @@

'use strict';
import { c as createRule, M as isNumericLiteral, K as KEYWORDS_JS, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import { tokenize } from 'espree';
import 'eslint-visitor-keys';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var espree = require('espree');
require('eslint-visitor-keys');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "quote-props",

@@ -75,3 +73,3 @@ package: "js",

function isKeyword(tokenStr) {
return utils.KEYWORDS_JS.includes(tokenStr);
return KEYWORDS_JS.includes(tokenStr);
}

@@ -97,3 +95,3 @@ function areQuotesRedundant(rawKey, tokens, skipNumberLiterals = false) {

try {
tokens = espree.tokenize(key.value);
tokens = tokenize(key.value);
} catch {

@@ -122,3 +120,3 @@ return;

});
} else if (NUMBERS && key.type === "Literal" && utils.isNumericLiteral(key)) {
} else if (NUMBERS && key.type === "Literal" && isNumericLiteral(key)) {
context.report({

@@ -171,3 +169,3 @@ node,

try {
tokens = espree.tokenize(key.value);
tokens = tokenize(key.value);
} catch {

@@ -248,4 +246,4 @@ necessaryQuotes = true;

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var quoteProps = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var quoteProps = createRule({
name: "quote-props",

@@ -267,3 +265,3 @@ package: "ts",

...node,
type: utils$1.AST_NODE_TYPES.Property,
type: AST_NODE_TYPES.Property,
shorthand: false,

@@ -278,3 +276,3 @@ method: false,

...node,
type: utils$1.AST_NODE_TYPES.Property,
type: AST_NODE_TYPES.Property,
shorthand: false,

@@ -289,3 +287,3 @@ method: true,

...node,
type: utils$1.AST_NODE_TYPES.Property,
type: AST_NODE_TYPES.Property,
key: node.id,

@@ -302,3 +300,3 @@ optional: false,

...node,
type: utils$1.AST_NODE_TYPES.ObjectExpression,
type: AST_NODE_TYPES.ObjectExpression,
properties: node.members

@@ -310,3 +308,3 @@ });

...node,
type: utils$1.AST_NODE_TYPES.ObjectExpression,
type: AST_NODE_TYPES.ObjectExpression,
properties: node.body

@@ -319,3 +317,3 @@ });

...node,
type: utils$1.AST_NODE_TYPES.ObjectExpression,
type: AST_NODE_TYPES.ObjectExpression,
properties: members.map((member) => ({ ...member, key: member.id }))

@@ -328,2 +326,2 @@ });

module.exports = quoteProps;
export { quoteProps as default };

54

dist/rules/quotes.js

@@ -1,8 +0,6 @@

'use strict';
import { O as LINEBREAKS, c as createRule, H as isTopLevelExpressionStatement, P as isParenthesised, Q as isSurroundedBy, R as hasOctalOrNonOctalDecimalEscapeSequence, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
require('eslint-visitor-keys');
require('espree');
function switchQuote(str) {

@@ -43,5 +41,5 @@ const newQuote = this.quote;

};
const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(utils.LINEBREAKS).join("")}]`, "u");
const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(LINEBREAKS).join("")}]`, "u");
const AVOID_ESCAPE = "avoid-escape";
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "quotes",

@@ -124,3 +122,3 @@ package: "js",

function isDirective(node) {
return node.type === "ExpressionStatement" && node.expression.type === "Literal" && typeof node.expression.value === "string" && !utils.isParenthesised(sourceCode, node.expression);
return node.type === "ExpressionStatement" && node.expression.type === "Literal" && typeof node.expression.value === "string" && !isParenthesised(sourceCode, node.expression);
}

@@ -130,3 +128,3 @@ function isExpressionInOrJustAfterDirectivePrologue(node) {

return false;
if (!utils.isTopLevelExpressionStatement(node.parent))
if (!isTopLevelExpressionStatement(node.parent))
return false;

@@ -152,3 +150,3 @@ const block = node.parent.parent;

case "ExpressionStatement":
return !utils.isParenthesised(sourceCode, node) && isExpressionInOrJustAfterDirectivePrologue(node);
return !isParenthesised(sourceCode, node) && isExpressionInOrJustAfterDirectivePrologue(node);
// LiteralPropertyName.

@@ -198,5 +196,5 @@ case "Property":

if (settings && typeof val === "string") {
let isValid = quoteOption === "backtick" && isAllowedAsNonBacktick(node) || isJSXLiteral(node) || utils.isSurroundedBy(rawVal, settings.quote);
let isValid = quoteOption === "backtick" && isAllowedAsNonBacktick(node) || isJSXLiteral(node) || isSurroundedBy(rawVal, settings.quote);
if (!isValid && avoidEscape)
isValid = utils.isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.includes(settings.quote);
isValid = isSurroundedBy(rawVal, settings.alternateQuote) && rawVal.includes(settings.quote);
if (!isValid) {

@@ -210,3 +208,3 @@ context.report({

fix(fixer) {
if (quoteOption === "backtick" && utils.hasOctalOrNonOctalDecimalEscapeSequence(rawVal)) {
if (quoteOption === "backtick" && hasOctalOrNonOctalDecimalEscapeSequence(rawVal)) {
return null;

@@ -233,3 +231,3 @@ }

fix(fixer) {
if (utils.isTopLevelExpressionStatement(node.parent) && !utils.isParenthesised(sourceCode, node)) {
if (isTopLevelExpressionStatement(node.parent) && !isParenthesised(sourceCode, node)) {
return null;

@@ -245,4 +243,4 @@ }

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var quotes = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var quotes = createRule({
name: "quotes",

@@ -273,15 +271,15 @@ package: "ts",

switch (parent?.type) {
case utils$1.AST_NODE_TYPES.TSAbstractMethodDefinition:
case utils$1.AST_NODE_TYPES.TSMethodSignature:
case utils$1.AST_NODE_TYPES.TSPropertySignature:
case utils$1.AST_NODE_TYPES.TSModuleDeclaration:
case utils$1.AST_NODE_TYPES.TSExternalModuleReference:
case AST_NODE_TYPES.TSAbstractMethodDefinition:
case AST_NODE_TYPES.TSMethodSignature:
case AST_NODE_TYPES.TSPropertySignature:
case AST_NODE_TYPES.TSModuleDeclaration:
case AST_NODE_TYPES.TSExternalModuleReference:
return true;
case utils$1.AST_NODE_TYPES.TSEnumMember:
case AST_NODE_TYPES.TSEnumMember:
return node === parent.id;
case utils$1.AST_NODE_TYPES.TSAbstractPropertyDefinition:
case utils$1.AST_NODE_TYPES.PropertyDefinition:
case AST_NODE_TYPES.TSAbstractPropertyDefinition:
case AST_NODE_TYPES.PropertyDefinition:
return parent.key === node && !parent.computed;
case utils$1.AST_NODE_TYPES.TSLiteralType:
return parent.parent?.type === utils$1.AST_NODE_TYPES.TSImportType;
case AST_NODE_TYPES.TSLiteralType:
return parent.parent?.type === AST_NODE_TYPES.TSImportType;
default:

@@ -304,2 +302,2 @@ return false;

module.exports = quotes;
export { quotes as default };

46

dist/rules/semi.js

@@ -1,9 +0,7 @@

'use strict';
import { c as createRule, f as isSemicolonToken, g as getNextLocation, I as FixTracker, s as isClosingBraceToken, i as isTokenOnSameLine, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
require('eslint-visitor-keys');
require('espree');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "semi",

@@ -83,3 +81,3 @@ package: "js",

start: lastToken.loc.end,
end: utils.getNextLocation(sourceCode, lastToken.loc.end)
end: getNextLocation(sourceCode, lastToken.loc.end)
};

@@ -93,3 +91,3 @@ fix = function(fixer) {

fix = function(fixer) {
return new utils.FixTracker(fixer, sourceCode).retainSurroundingTokens(lastToken).remove(lastToken);
return new FixTracker(fixer, sourceCode).retainSurroundingTokens(lastToken).remove(lastToken);
};

@@ -106,6 +104,6 @@ }

const nextToken = sourceCode.getTokenAfter(semiToken);
return !nextToken || utils.isClosingBraceToken(nextToken) || utils.isSemicolonToken(nextToken);
return !nextToken || isClosingBraceToken(nextToken) || isSemicolonToken(nextToken);
}
function isEndOfArrowBlock(lastToken) {
if (!utils.isClosingBraceToken(lastToken))
if (!isClosingBraceToken(lastToken))
return false;

@@ -130,3 +128,3 @@ const node = sourceCode.getNodeByRangeIndex(lastToken.range[0]);

const nextToken = sourceCode.getTokenAfter(node);
return !!nextToken && utils.isTokenOnSameLine(prevToken, nextToken);
return !!nextToken && isTokenOnSameLine(prevToken, nextToken);
}

@@ -190,3 +188,3 @@ function maybeAsiHazardAfter(node) {

const lastToken = sourceCode.getLastToken(node);
const isSemi = utils.isSemicolonToken(lastToken);
const isSemi = isSemicolonToken(lastToken);
if (never) {

@@ -239,4 +237,4 @@ const nextToken = sourceCode.getTokenAfter(node);

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var semi = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var semi = createRule({
name: "semi",

@@ -266,9 +264,9 @@ package: "ts",

const nodesToCheck = [
utils$1.AST_NODE_TYPES.PropertyDefinition,
utils$1.AST_NODE_TYPES.TSAbstractPropertyDefinition,
utils$1.AST_NODE_TYPES.TSDeclareFunction,
utils$1.AST_NODE_TYPES.TSExportAssignment,
utils$1.AST_NODE_TYPES.TSImportEqualsDeclaration,
utils$1.AST_NODE_TYPES.TSTypeAliasDeclaration,
utils$1.AST_NODE_TYPES.TSEmptyBodyFunctionExpression
AST_NODE_TYPES.PropertyDefinition,
AST_NODE_TYPES.TSAbstractPropertyDefinition,
AST_NODE_TYPES.TSDeclareFunction,
AST_NODE_TYPES.TSExportAssignment,
AST_NODE_TYPES.TSImportEqualsDeclaration,
AST_NODE_TYPES.TSTypeAliasDeclaration,
AST_NODE_TYPES.TSEmptyBodyFunctionExpression
].reduce((acc, node) => {

@@ -282,3 +280,3 @@ acc[node] = checkForSemicolon;

ExportDefaultDeclaration(node) {
if (node.declaration.type !== utils$1.AST_NODE_TYPES.TSInterfaceDeclaration)
if (node.declaration.type !== AST_NODE_TYPES.TSInterfaceDeclaration)
rules.ExportDefaultDeclaration(node);

@@ -290,2 +288,2 @@ }

module.exports = semi;
export { semi as default };

26

dist/rules/space-before-blocks.js

@@ -1,13 +0,11 @@

'use strict';
import { c as createRule, i as isTokenOnSameLine, T as isArrowToken, x as isKeywordToken, q as isColonToken, U as getSwitchCaseColonToken, V as isFunction, a as castRuleModule } from '../utils.js';
import { isTokenOnSameLine as isTokenOnSameLine$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
function isFunctionBody(node) {
const parent = node.parent;
return node.type === "BlockStatement" && utils.isFunction(parent) && parent.body === node;
return node.type === "BlockStatement" && isFunction(parent) && parent.body === node;
}
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "space-before-blocks",

@@ -79,7 +77,7 @@ package: "js",

function isConflicted(precedingToken, node) {
return utils.isArrowToken(precedingToken) || utils.isKeywordToken(precedingToken) && !isFunctionBody(node) || utils.isColonToken(precedingToken) && "parent" in node && node.parent && node.parent.type === "SwitchCase" && precedingToken === utils.getSwitchCaseColonToken(node.parent, sourceCode);
return isArrowToken(precedingToken) || isKeywordToken(precedingToken) && !isFunctionBody(node) || isColonToken(precedingToken) && "parent" in node && node.parent && node.parent.type === "SwitchCase" && precedingToken === getSwitchCaseColonToken(node.parent, sourceCode);
}
function checkPrecedingSpace(node) {
const precedingToken = sourceCode.getTokenBefore(node);
if (precedingToken && !isConflicted(precedingToken, node) && utils.isTokenOnSameLine(precedingToken, node)) {
if (precedingToken && !isConflicted(precedingToken, node) && isTokenOnSameLine(precedingToken, node)) {
const hasSpace = sourceCode.isSpaceBetween(precedingToken, node);

@@ -134,4 +132,4 @@ let requireSpace;

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
var spaceBeforeBlocks = utils.createRule({
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
var spaceBeforeBlocks = createRule({
name: "space-before-blocks",

@@ -160,3 +158,3 @@ package: "ts",

const precedingToken = sourceCode.getTokenBefore(node);
if (precedingToken && astUtils.isTokenOnSameLine(precedingToken, node)) {
if (precedingToken && isTokenOnSameLine$1(precedingToken, node)) {
const hasSpace = sourceCode.isSpaceBetween(

@@ -201,2 +199,2 @@ precedingToken,

module.exports = spaceBeforeBlocks;
export { spaceBeforeBlocks as default };

24

dist/rules/space-before-function-paren.js

@@ -1,10 +0,8 @@

'use strict';
import { c as createRule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import { isOpeningParenToken } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
var spaceBeforeFunctionParen = utils.createRule({
var spaceBeforeFunctionParen = createRule({
name: "space-before-function-paren",

@@ -60,7 +58,7 @@ package: "ts",

const parent = node.parent;
return parent.type === utils$1.AST_NODE_TYPES.MethodDefinition || parent.type === utils$1.AST_NODE_TYPES.TSAbstractMethodDefinition || parent.type === utils$1.AST_NODE_TYPES.Property && (parent.kind === "get" || parent.kind === "set" || parent.method);
return parent.type === AST_NODE_TYPES.MethodDefinition || parent.type === AST_NODE_TYPES.TSAbstractMethodDefinition || parent.type === AST_NODE_TYPES.Property && (parent.kind === "get" || parent.kind === "set" || parent.method);
}
function getConfigForFunction(node) {
if (node.type === utils$1.AST_NODE_TYPES.ArrowFunctionExpression) {
if (node.async && astUtils.isOpeningParenToken(sourceCode.getFirstToken(node, { skip: 1 }))) {
if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) {
if (node.async && isOpeningParenToken(sourceCode.getFirstToken(node, { skip: 1 }))) {
return overrideConfig.asyncArrow ?? baseConfig;

@@ -85,3 +83,3 @@ }

} else {
rightToken = sourceCode.getFirstToken(node, astUtils.isOpeningParenToken);
rightToken = sourceCode.getFirstToken(node, isOpeningParenToken);
leftToken = sourceCode.getTokenBefore(rightToken);

@@ -127,2 +125,2 @@ }

module.exports = spaceBeforeFunctionParen;
export { spaceBeforeFunctionParen as default };

26

dist/rules/space-infix-ops.js

@@ -1,10 +0,8 @@

'use strict';
import { c as createRule, p as isEqToken, a as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
import { isNotOpeningParenToken } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "space-infix-ops",

@@ -104,3 +102,3 @@ package: "js",

return;
const operatorToken = sourceCode.getTokenBefore(node.value, utils.isEqToken);
const operatorToken = sourceCode.getTokenBefore(node.value, isEqToken);
const leftToken = sourceCode.getTokenBefore(operatorToken);

@@ -116,5 +114,5 @@ const rightToken = sourceCode.getTokenAfter(operatorToken);

const baseRule = /* @__PURE__ */ utils.castRuleModule(_baseRule);
const baseRule = /* @__PURE__ */ castRuleModule(_baseRule);
const UNIONS = ["|", "&"];
var spaceInfixOps = utils.createRule({
var spaceInfixOps = createRule({
name: "space-infix-ops",

@@ -162,3 +160,3 @@ package: "ts",

function isSpaceChar(token) {
return token.type === utils$1.AST_TOKEN_TYPES.Punctuator && /^[=?:]$/.test(token.value);
return token.type === AST_TOKEN_TYPES.Punctuator && /^[=?:]$/.test(token.value);
}

@@ -189,3 +187,3 @@ function checkAndReportAssignmentSpace(node, leftNode, rightNode) {

types.forEach((type) => {
const skipFunctionParenthesis = type.type === utils$1.AST_NODE_TYPES.TSFunctionType ? astUtils.isNotOpeningParenToken : 0;
const skipFunctionParenthesis = type.type === AST_NODE_TYPES.TSFunctionType ? isNotOpeningParenToken : 0;
const operator = sourceCode.getTokenBefore(

@@ -227,2 +225,2 @@ type,

module.exports = spaceInfixOps;
export { spaceInfixOps as default };

30

dist/rules/type-annotation-spacing.js

@@ -1,12 +0,10 @@

'use strict';
import { c as createRule } from '../utils.js';
import { isTSFunctionType, isTSConstructorType, isIdentifier, isClassOrTypeElement, isFunction, isVariableDeclarator, isFunctionOrFunctionType } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
var utils = require('../utils.js');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
function createRules(options) {
const globals = {
...options?.before !== undefined ? { before: options.before } : {},
...options?.after !== undefined ? { after: options.after } : {}
...options?.before !== void 0 ? { before: options.before } : {},
...options?.after !== void 0 ? { after: options.after } : {}
};

@@ -35,5 +33,5 @@ const override = options?.overrides ?? {};

const scope = node?.parent;
if (astUtils.isVariableDeclarator(scope))
if (isVariableDeclarator(scope))
return rules.variable;
else if (astUtils.isFunctionOrFunctionType(scope))
else if (isFunctionOrFunctionType(scope))
return rules.parameter;

@@ -44,13 +42,13 @@ return rules.colon;

const scope = node?.parent?.parent;
if (astUtils.isTSFunctionType(scope) || astUtils.isTSConstructorType(scope))
if (isTSFunctionType(scope) || isTSConstructorType(scope))
return rules.arrow;
else if (astUtils.isIdentifier(scope))
else if (isIdentifier(scope))
return getIdentifierRules(rules, scope);
else if (astUtils.isClassOrTypeElement(scope))
else if (isClassOrTypeElement(scope))
return rules.property;
else if (astUtils.isFunction(scope))
else if (isFunction(scope))
return rules.returnType;
return rules.colon;
}
var typeAnnotationSpacing = utils.createRule({
var typeAnnotationSpacing = createRule({
name: "type-annotation-spacing",

@@ -215,2 +213,2 @@ package: "ts",

module.exports = typeAnnotationSpacing;
export { typeAnnotationSpacing as default };

84

dist/utils.js

@@ -1,7 +0,5 @@

'use strict';
import { KEYS } from 'eslint-visitor-keys';
import { tokenize, latestEcmaVersion } from 'espree';
var eslintVisitorKeys = require('eslint-visitor-keys');
var espree = require('espree');
function createAllConfigs(plugin, name, flat, filter) {
function createAllConfigs(plugin, name, filter) {
const rules = Object.fromEntries(

@@ -15,15 +13,8 @@ Object.entries(plugin.rules).filter(

);
if (flat) {
return {
plugins: {
[name]: plugin
},
rules
};
} else {
return {
plugins: [name],
rules
};
}
return {
plugins: {
[name]: plugin
},
rules
};
}

@@ -310,3 +301,3 @@

default:
if (node.type in eslintVisitorKeys.KEYS)
if (node.type in KEYS)
return 20;

@@ -340,3 +331,3 @@ return -1;

comment: true,
ecmaVersion: espree.latestEcmaVersion,
ecmaVersion: latestEcmaVersion,
range: true

@@ -348,3 +339,3 @@ };

try {
tokens = espree.tokenize(leftValue, espreeOptions);
tokens = tokenize(leftValue, espreeOptions);
} catch {

@@ -369,3 +360,3 @@ return false;

try {
tokens = espree.tokenize(rightValue, espreeOptions);
tokens = tokenize(rightValue, espreeOptions);
} catch {

@@ -635,49 +626,2 @@ return false;

exports.COMMENTS_IGNORE_PATTERN = COMMENTS_IGNORE_PATTERN;
exports.FixTracker = FixTracker;
exports.KEYWORDS_JS = KEYWORDS_JS;
exports.LINEBREAKS = LINEBREAKS;
exports.LINEBREAK_MATCHER = LINEBREAK_MATCHER;
exports.NullThrowsReasons = NullThrowsReasons;
exports.STATEMENT_LIST_PARENTS = STATEMENT_LIST_PARENTS;
exports.canTokensBeAdjacent = canTokensBeAdjacent;
exports.castRuleModule = castRuleModule;
exports.createAllConfigs = createAllConfigs;
exports.createGlobalLinebreakMatcher = createGlobalLinebreakMatcher;
exports.createRule = createRule;
exports.deepMerge = deepMerge;
exports.getNextLocation = getNextLocation;
exports.getPrecedence = getPrecedence;
exports.getStaticPropertyName = getStaticPropertyName;
exports.getStringLength = getStringLength;
exports.getSwitchCaseColonToken = getSwitchCaseColonToken;
exports.hasOctalOrNonOctalDecimalEscapeSequence = hasOctalOrNonOctalDecimalEscapeSequence;
exports.isArrowToken = isArrowToken;
exports.isClosingBraceToken = isClosingBraceToken;
exports.isClosingBracketToken = isClosingBracketToken;
exports.isClosingParenToken = isClosingParenToken;
exports.isColonToken = isColonToken;
exports.isCommaToken = isCommaToken;
exports.isCommentToken = isCommentToken;
exports.isDecimalInteger = isDecimalInteger;
exports.isEqToken = isEqToken;
exports.isFunction = isFunction;
exports.isKeywordToken = isKeywordToken;
exports.isMixedLogicalAndCoalesceExpressions = isMixedLogicalAndCoalesceExpressions;
exports.isNotClosingParenToken = isNotClosingParenToken;
exports.isNotCommaToken = isNotCommaToken;
exports.isNotOpeningParenToken = isNotOpeningParenToken;
exports.isNotSemicolonToken = isNotSemicolonToken;
exports.isNumericLiteral = isNumericLiteral;
exports.isOpeningBraceToken = isOpeningBraceToken;
exports.isOpeningBracketToken = isOpeningBracketToken;
exports.isOpeningParenToken = isOpeningParenToken;
exports.isParenthesised = isParenthesised;
exports.isParenthesized = isParenthesized;
exports.isQuestionDotToken = isQuestionDotToken;
exports.isSemicolonToken = isSemicolonToken;
exports.isSurroundedBy = isSurroundedBy;
exports.isTokenOnSameLine = isTokenOnSameLine;
exports.isTopLevelExpressionStatement = isTopLevelExpressionStatement;
exports.nullThrows = nullThrows;
exports.skipChainExpression = skipChainExpression;
export { getPrecedence as A, isDecimalInteger as B, COMMENTS_IGNORE_PATTERN as C, skipChainExpression as D, isParenthesized as E, isMixedLogicalAndCoalesceExpressions as F, canTokensBeAdjacent as G, isTopLevelExpressionStatement as H, FixTracker as I, isNotCommaToken as J, KEYWORDS_JS as K, LINEBREAK_MATCHER as L, isNumericLiteral as M, NullThrowsReasons as N, LINEBREAKS as O, isParenthesised as P, isSurroundedBy as Q, hasOctalOrNonOctalDecimalEscapeSequence as R, STATEMENT_LIST_PARENTS as S, isArrowToken as T, getSwitchCaseColonToken as U, isFunction as V, castRuleModule as a, isCommaToken as b, createRule as c, createAllConfigs as d, isCommentToken as e, isSemicolonToken as f, getNextLocation as g, isOpeningParenToken as h, isTokenOnSameLine as i, isQuestionDotToken as j, isClosingParenToken as k, isNotOpeningParenToken as l, isOpeningBraceToken as m, isOpeningBracketToken as n, isClosingBracketToken as o, isEqToken as p, isColonToken as q, isNotClosingParenToken as r, isClosingBraceToken as s, isNotSemicolonToken as t, createGlobalLinebreakMatcher as u, getStaticPropertyName as v, getStringLength as w, isKeywordToken as x, deepMerge as y, nullThrows as z };

9

package.json
{
"name": "@stylistic/eslint-plugin-ts",
"type": "commonjs",
"version": "3.1.0",
"type": "module",
"version": "4.0.0-beta.1",
"author": "Anthony Fu <anthonyfu117@hotmail.com>",

@@ -19,3 +19,2 @@ "license": "MIT",

"types": "./dist/dts/index.d.ts",
"require": "./dist/index.js",
"default": "./dist/index.js"

@@ -64,6 +63,6 @@ },

"peerDependencies": {
"eslint": ">=8.40.0"
"eslint": ">=9.0.0"
},
"dependencies": {
"@typescript-eslint/utils": "^8.13.0",
"@typescript-eslint/utils": "^8.23.0",
"eslint-visitor-keys": "^4.2.0",

@@ -70,0 +69,0 @@ "espree": "^10.3.0"

dist/rules/indent.js

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc