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

@stylistic/eslint-plugin

Package Overview
Dependencies
Maintainers
1
Versions
71
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@stylistic/eslint-plugin - npm Package Compare versions

Comparing version 3.1.0 to 4.0.0-beta.1

254

dist/configs.js

@@ -1,100 +0,98 @@

'use strict';
import { p as createAllConfigs } from './utils.js';
import arrayBracketNewline from './rules/array-bracket-newline.js';
import arrayBracketSpacing from './rules/array-bracket-spacing.js';
import arrayElementNewline from './rules/array-element-newline.js';
import arrowParens from './rules/arrow-parens.js';
import arrowSpacing from './rules/arrow-spacing.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 commaStyle from './rules/comma-style.js';
import computedPropertySpacing from './rules/computed-property-spacing.js';
import curlyNewline from './rules/curly-newline.js';
import dotLocation from './rules/dot-location.js';
import eolLast from './rules/eol-last.js';
import functionCallArgumentNewline from './rules/function-call-argument-newline.js';
import functionCallSpacing from './rules/function-call-spacing.js';
import functionParenNewline from './rules/function-paren-newline.js';
import generatorStarSpacing from './rules/generator-star-spacing.js';
import implicitArrowLinebreak from './rules/implicit-arrow-linebreak.js';
import indentBinaryOps from './rules/indent-binary-ops.js';
import indent from './rules/indent.js';
import jsxChildElementSpacing from './rules/jsx-child-element-spacing.js';
import jsxClosingBracketLocation from './rules/jsx-closing-bracket-location.js';
import jsxClosingTagLocation from './rules/jsx-closing-tag-location.js';
import jsxCurlyBracePresence from './rules/jsx-curly-brace-presence.js';
import jsxCurlyNewline from './rules/jsx-curly-newline.js';
import jsxCurlySpacing from './rules/jsx-curly-spacing.js';
import jsxEqualsSpacing from './rules/jsx-equals-spacing.js';
import jsxFirstPropNewLine from './rules/jsx-first-prop-new-line.js';
import jsxFunctionCallNewline from './rules/jsx-function-call-newline.js';
import jsxIndentProps from './rules/jsx-indent-props.js';
import jsxIndent from './rules/jsx-indent.js';
import jsxMaxPropsPerLine from './rules/jsx-max-props-per-line.js';
import jsxNewline from './rules/jsx-newline.js';
import jsxOneExpressionPerLine from './rules/jsx-one-expression-per-line.js';
import jsxPascalCase from './rules/jsx-pascal-case.js';
import jsxPropsNoMultiSpaces from './rules/jsx-props-no-multi-spaces.js';
import jsxQuotes from './rules/jsx-quotes.js';
import jsxSelfClosingComp from './rules/jsx-self-closing-comp.js';
import jsxSortProps from './rules/jsx-sort-props.js';
import jsxTagSpacing from './rules/jsx-tag-spacing.js';
import jsxWrapMultilines from './rules/jsx-wrap-multilines.js';
import keySpacing from './rules/key-spacing.js';
import keywordSpacing from './rules/keyword-spacing.js';
import lineCommentPosition from './rules/line-comment-position.js';
import linebreakStyle from './rules/linebreak-style.js';
import linesAroundComment from './rules/lines-around-comment.js';
import linesBetweenClassMembers from './rules/lines-between-class-members.js';
import maxLen from './rules/max-len.js';
import maxStatementsPerLine from './rules/max-statements-per-line.js';
import memberDelimiterStyle from './rules/member-delimiter-style.js';
import multilineCommentStyle from './rules/multiline-comment-style.js';
import multilineTernary from './rules/multiline-ternary.js';
import newParens from './rules/new-parens.js';
import newlinePerChainedCall from './rules/newline-per-chained-call.js';
import noConfusingArrow from './rules/no-confusing-arrow.js';
import noExtraParens from './rules/no-extra-parens.js';
import noExtraSemi from './rules/no-extra-semi.js';
import noFloatingDecimal from './rules/no-floating-decimal.js';
import noMixedOperators from './rules/no-mixed-operators.js';
import noMixedSpacesAndTabs from './rules/no-mixed-spaces-and-tabs.js';
import noMultiSpaces from './rules/no-multi-spaces.js';
import noMultipleEmptyLines from './rules/no-multiple-empty-lines.js';
import noTabs from './rules/no-tabs.js';
import noTrailingSpaces from './rules/no-trailing-spaces.js';
import noWhitespaceBeforeProperty from './rules/no-whitespace-before-property.js';
import nonblockStatementBodyPosition from './rules/nonblock-statement-body-position.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 oneVarDeclarationPerLine from './rules/one-var-declaration-per-line.js';
import operatorLinebreak from './rules/operator-linebreak.js';
import paddedBlocks from './rules/padded-blocks.js';
import paddingLineBetweenStatements from './rules/padding-line-between-statements.js';
import quoteProps from './rules/quote-props.js';
import quotes from './rules/quotes.js';
import restSpreadSpacing from './rules/rest-spread-spacing.js';
import semiSpacing from './rules/semi-spacing.js';
import semiStyle from './rules/semi-style.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 spaceInParens from './rules/space-in-parens.js';
import spaceInfixOps from './rules/space-infix-ops.js';
import spaceUnaryOps from './rules/space-unary-ops.js';
import spacedComment from './rules/spaced-comment.js';
import switchColonSpacing from './rules/switch-colon-spacing.js';
import templateCurlySpacing from './rules/template-curly-spacing.js';
import templateTagSpacing from './rules/template-tag-spacing.js';
import typeAnnotationSpacing from './rules/type-annotation-spacing.js';
import typeGenericSpacing from './rules/type-generic-spacing.js';
import typeNamedTupleSpacing from './rules/type-named-tuple-spacing.js';
import wrapIife from './rules/wrap-iife.js';
import wrapRegex from './rules/wrap-regex.js';
import yieldStarSpacing from './rules/yield-star-spacing.js';
var utils = require('./utils.js');
var arrayBracketNewline = require('./rules/array-bracket-newline.js');
var arrayBracketSpacing = require('./rules/array-bracket-spacing.js');
var arrayElementNewline = require('./rules/array-element-newline.js');
var arrowParens = require('./rules/arrow-parens.js');
var arrowSpacing = require('./rules/arrow-spacing.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 commaStyle = require('./rules/comma-style.js');
var computedPropertySpacing = require('./rules/computed-property-spacing.js');
var curlyNewline = require('./rules/curly-newline.js');
var dotLocation = require('./rules/dot-location.js');
var eolLast = require('./rules/eol-last.js');
var functionCallArgumentNewline = require('./rules/function-call-argument-newline.js');
var functionCallSpacing = require('./rules/function-call-spacing.js');
var functionParenNewline = require('./rules/function-paren-newline.js');
var generatorStarSpacing = require('./rules/generator-star-spacing.js');
var implicitArrowLinebreak = require('./rules/implicit-arrow-linebreak.js');
var indentBinaryOps = require('./rules/indent-binary-ops.js');
var indent = require('./rules/indent.js');
var jsxChildElementSpacing = require('./rules/jsx-child-element-spacing.js');
var jsxClosingBracketLocation = require('./rules/jsx-closing-bracket-location.js');
var jsxClosingTagLocation = require('./rules/jsx-closing-tag-location.js');
var jsxCurlyBracePresence = require('./rules/jsx-curly-brace-presence.js');
var jsxCurlyNewline = require('./rules/jsx-curly-newline.js');
var jsxCurlySpacing = require('./rules/jsx-curly-spacing.js');
var jsxEqualsSpacing = require('./rules/jsx-equals-spacing.js');
var jsxFirstPropNewLine = require('./rules/jsx-first-prop-new-line.js');
var jsxFunctionCallNewline = require('./rules/jsx-function-call-newline.js');
var jsxIndentProps = require('./rules/jsx-indent-props.js');
var jsxIndent = require('./rules/jsx-indent.js');
var jsxMaxPropsPerLine = require('./rules/jsx-max-props-per-line.js');
var jsxNewline = require('./rules/jsx-newline.js');
var jsxOneExpressionPerLine = require('./rules/jsx-one-expression-per-line.js');
var jsxPascalCase = require('./rules/jsx-pascal-case.js');
var jsxPropsNoMultiSpaces = require('./rules/jsx-props-no-multi-spaces.js');
var jsxQuotes = require('./rules/jsx-quotes.js');
var jsxSelfClosingComp = require('./rules/jsx-self-closing-comp.js');
var jsxSortProps = require('./rules/jsx-sort-props.js');
var jsxTagSpacing = require('./rules/jsx-tag-spacing.js');
var jsxWrapMultilines = require('./rules/jsx-wrap-multilines.js');
var keySpacing = require('./rules/key-spacing.js');
var keywordSpacing = require('./rules/keyword-spacing.js');
var lineCommentPosition = require('./rules/line-comment-position.js');
var linebreakStyle = require('./rules/linebreak-style.js');
var linesAroundComment = require('./rules/lines-around-comment.js');
var linesBetweenClassMembers = require('./rules/lines-between-class-members.js');
var maxLen = require('./rules/max-len.js');
var maxStatementsPerLine = require('./rules/max-statements-per-line.js');
var memberDelimiterStyle = require('./rules/member-delimiter-style.js');
var multilineCommentStyle = require('./rules/multiline-comment-style.js');
var multilineTernary = require('./rules/multiline-ternary.js');
var newParens = require('./rules/new-parens.js');
var newlinePerChainedCall = require('./rules/newline-per-chained-call.js');
var noConfusingArrow = require('./rules/no-confusing-arrow.js');
var noExtraParens = require('./rules/no-extra-parens.js');
var noExtraSemi = require('./rules/no-extra-semi.js');
var noFloatingDecimal = require('./rules/no-floating-decimal.js');
var noMixedOperators = require('./rules/no-mixed-operators.js');
var noMixedSpacesAndTabs = require('./rules/no-mixed-spaces-and-tabs.js');
var noMultiSpaces = require('./rules/no-multi-spaces.js');
var noMultipleEmptyLines = require('./rules/no-multiple-empty-lines.js');
var noTabs = require('./rules/no-tabs.js');
var noTrailingSpaces = require('./rules/no-trailing-spaces.js');
var noWhitespaceBeforeProperty = require('./rules/no-whitespace-before-property.js');
var nonblockStatementBodyPosition = require('./rules/nonblock-statement-body-position.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 oneVarDeclarationPerLine = require('./rules/one-var-declaration-per-line.js');
var operatorLinebreak = require('./rules/operator-linebreak.js');
var paddedBlocks = require('./rules/padded-blocks.js');
var paddingLineBetweenStatements = require('./rules/padding-line-between-statements.js');
var quoteProps = require('./rules/quote-props.js');
var quotes = require('./rules/quotes.js');
var restSpreadSpacing = require('./rules/rest-spread-spacing.js');
var semiSpacing = require('./rules/semi-spacing.js');
var semiStyle = require('./rules/semi-style.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 spaceInParens = require('./rules/space-in-parens.js');
var spaceInfixOps = require('./rules/space-infix-ops.js');
var spaceUnaryOps = require('./rules/space-unary-ops.js');
var spacedComment = require('./rules/spaced-comment.js');
var switchColonSpacing = require('./rules/switch-colon-spacing.js');
var templateCurlySpacing = require('./rules/template-curly-spacing.js');
var templateTagSpacing = require('./rules/template-tag-spacing.js');
var typeAnnotationSpacing = require('./rules/type-annotation-spacing.js');
var typeGenericSpacing = require('./rules/type-generic-spacing.js');
var typeNamedTupleSpacing = require('./rules/type-named-tuple-spacing.js');
var wrapIife = require('./rules/wrap-iife.js');
var wrapRegex = require('./rules/wrap-regex.js');
var yieldStarSpacing = require('./rules/yield-star-spacing.js');
var rules = {

@@ -209,3 +207,2 @@ "array-bracket-newline": arrayBracketNewline,

commaDangle = "always-multiline",
flat = true,
indent = 2,

@@ -371,17 +368,8 @@ jsx = true,

}
if (flat) {
return {
plugins: {
[pluginName]: plugin
},
rules
};
} else {
if (pluginName !== "@stylistic")
throw new Error("PluginName in non-flat config can not be customized");
return {
plugins: ["@stylistic"],
rules
};
}
return {
plugins: {
[pluginName]: plugin
},
rules
};
}

@@ -500,3 +488,2 @@

const recommendedExtends = /* @__PURE__ */ customize({ flat: false });
const allConfigsIgnore = [

@@ -508,36 +495,13 @@ // Exclude all JSX rules

];
const all = /* @__PURE__ */ createAllConfigs(plugin, "@stylistic", (name) => !allConfigsIgnore.some((re) => re.test(name)));
const recommended = /* @__PURE__ */ customize();
const configs = {
/**
* Disable all legacy rules from `eslint`, `@typescript-eslint` and `eslint-plugin-react`
*
* This config works for both flat and legacy config format
*/
"disable-legacy": config,
/**
* A factory function to customize the recommended config
*/
"customize": customize,
/**
* The default recommended config in Flat Config Format
*/
"recommended-flat": /* @__PURE__ */ customize(),
/**
* The default recommended config in Legacy Config Format
*/
"recommended-extends": recommendedExtends,
/**
* Enable all rules, in Flat Config Format
*/
"all-flat": utils.createAllConfigs(plugin, "@stylistic", true, (name) => !allConfigsIgnore.some((re) => re.test(name))),
/**
* Enable all rules, in Legacy Config Format
*/
"all-extends": utils.createAllConfigs(plugin, "@stylistic", false, (name) => !allConfigsIgnore.some((re) => re.test(name))),
/**
* @deprecated Use `recommended-extends` instead
*/
"recommended-legacy": recommendedExtends
"recommended": recommended,
"recommended-flat": recommended,
"all": all,
"all-flat": all
};
exports.configs = configs;
exports.plugin = plugin;
export { configs as c, plugin as p };

30

dist/dts/index.d.ts

@@ -5,9 +5,4 @@ import { Linter, Rule, ESLint } from 'eslint';

interface StylisticCustomizeOptions<Flat extends boolean = true> {
interface StylisticCustomizeOptions {
/**
* Get a flat config
* @default true
*/
flat?: Flat
/**
* The name of the registered plugin, used to prefix rule IDs

@@ -78,4 +73,3 @@ * @default '@stylistic'

declare function customize(options: StylisticCustomizeOptions<false>): Linter.BaseConfig
declare function customize(options?: StylisticCustomizeOptions<true>): Linter.Config
declare function customize(options?: StylisticCustomizeOptions): Linter.Config

@@ -96,19 +90,19 @@ declare const configs: {

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

@@ -115,0 +109,0 @@

214

dist/index.js

@@ -1,110 +0,108 @@

'use strict';
import { p as plugin, c as configs } from './configs.js';
import './utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
import './rules/array-bracket-newline.js';
import './rules/array-bracket-spacing.js';
import './rules/array-element-newline.js';
import './rules/arrow-parens.js';
import './rules/arrow-spacing.js';
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/comma-style.js';
import './rules/computed-property-spacing.js';
import './rules/curly-newline.js';
import './rules/dot-location.js';
import './rules/eol-last.js';
import './rules/function-call-argument-newline.js';
import './rules/function-call-spacing.js';
import './rules/function-paren-newline.js';
import './rules/generator-star-spacing.js';
import './rules/implicit-arrow-linebreak.js';
import './rules/indent-binary-ops.js';
import './rules/indent.js';
import './rules/jsx-child-element-spacing.js';
import './rules/jsx-closing-bracket-location.js';
import './rules/jsx-closing-tag-location.js';
import './rules/jsx-curly-brace-presence.js';
import './rules/jsx-curly-newline.js';
import './rules/jsx-curly-spacing.js';
import './rules/jsx-equals-spacing.js';
import './rules/jsx-first-prop-new-line.js';
import './rules/jsx-function-call-newline.js';
import './rules/jsx-indent-props.js';
import './rules/jsx-indent.js';
import './rules/jsx-max-props-per-line.js';
import './rules/jsx-newline.js';
import './rules/jsx-one-expression-per-line.js';
import './rules/jsx-pascal-case.js';
import 'picomatch';
import './rules/jsx-props-no-multi-spaces.js';
import './rules/jsx-quotes.js';
import './rules/jsx-self-closing-comp.js';
import './rules/jsx-sort-props.js';
import './rules/jsx-tag-spacing.js';
import './rules/jsx-wrap-multilines.js';
import './rules/key-spacing.js';
import './rules/keyword-spacing.js';
import './rules/line-comment-position.js';
import './rules/linebreak-style.js';
import './rules/lines-around-comment.js';
import './rules/lines-between-class-members.js';
import './rules/max-len.js';
import './rules/max-statements-per-line.js';
import './rules/member-delimiter-style.js';
import './rules/multiline-comment-style.js';
import './rules/multiline-ternary.js';
import './rules/new-parens.js';
import './rules/newline-per-chained-call.js';
import './rules/no-confusing-arrow.js';
import './rules/no-extra-parens.js';
import './rules/no-extra-semi.js';
import './rules/no-floating-decimal.js';
import './rules/no-mixed-operators.js';
import './rules/no-mixed-spaces-and-tabs.js';
import './rules/no-multi-spaces.js';
import './rules/no-multiple-empty-lines.js';
import './rules/no-tabs.js';
import './rules/no-trailing-spaces.js';
import './rules/no-whitespace-before-property.js';
import './rules/nonblock-statement-body-position.js';
import './rules/object-curly-newline.js';
import './rules/object-curly-spacing.js';
import './rules/object-property-newline.js';
import './rules/one-var-declaration-per-line.js';
import './rules/operator-linebreak.js';
import './rules/padded-blocks.js';
import './rules/padding-line-between-statements.js';
import './rules/quote-props.js';
import './rules/quotes.js';
import './rules/rest-spread-spacing.js';
import './rules/semi-spacing.js';
import './rules/semi-style.js';
import './rules/semi.js';
import './rules/space-before-blocks.js';
import './rules/space-before-function-paren.js';
import './rules/space-in-parens.js';
import './rules/space-infix-ops.js';
import './rules/space-unary-ops.js';
import './rules/spaced-comment.js';
import './vendor.js';
import './rules/switch-colon-spacing.js';
import './rules/template-curly-spacing.js';
import './rules/template-tag-spacing.js';
import './rules/type-annotation-spacing.js';
import './rules/type-generic-spacing.js';
import './rules/type-named-tuple-spacing.js';
import './rules/wrap-iife.js';
import './rules/wrap-regex.js';
import './rules/yield-star-spacing.js';
var configs = require('./configs.js');
require('./utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
require('./rules/array-bracket-newline.js');
require('./rules/array-bracket-spacing.js');
require('./rules/array-element-newline.js');
require('./rules/arrow-parens.js');
require('./rules/arrow-spacing.js');
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/comma-style.js');
require('./rules/computed-property-spacing.js');
require('./rules/curly-newline.js');
require('./rules/dot-location.js');
require('./rules/eol-last.js');
require('./rules/function-call-argument-newline.js');
require('./rules/function-call-spacing.js');
require('./rules/function-paren-newline.js');
require('./rules/generator-star-spacing.js');
require('./rules/implicit-arrow-linebreak.js');
require('./rules/indent-binary-ops.js');
require('./rules/indent.js');
require('./rules/jsx-child-element-spacing.js');
require('./rules/jsx-closing-bracket-location.js');
require('./rules/jsx-closing-tag-location.js');
require('./rules/jsx-curly-brace-presence.js');
require('./rules/jsx-curly-newline.js');
require('./rules/jsx-curly-spacing.js');
require('./rules/jsx-equals-spacing.js');
require('./rules/jsx-first-prop-new-line.js');
require('./rules/jsx-function-call-newline.js');
require('./rules/jsx-indent-props.js');
require('./rules/jsx-indent.js');
require('./rules/jsx-max-props-per-line.js');
require('./rules/jsx-newline.js');
require('./rules/jsx-one-expression-per-line.js');
require('./rules/jsx-pascal-case.js');
require('picomatch');
require('./rules/jsx-props-no-multi-spaces.js');
require('./rules/jsx-quotes.js');
require('./rules/jsx-self-closing-comp.js');
require('./rules/jsx-sort-props.js');
require('./rules/jsx-tag-spacing.js');
require('./rules/jsx-wrap-multilines.js');
require('./rules/key-spacing.js');
require('./rules/keyword-spacing.js');
require('./rules/line-comment-position.js');
require('./rules/linebreak-style.js');
require('./rules/lines-around-comment.js');
require('./rules/lines-between-class-members.js');
require('./rules/max-len.js');
require('./rules/max-statements-per-line.js');
require('./rules/member-delimiter-style.js');
require('./rules/multiline-comment-style.js');
require('./rules/multiline-ternary.js');
require('./rules/new-parens.js');
require('./rules/newline-per-chained-call.js');
require('./rules/no-confusing-arrow.js');
require('./rules/no-extra-parens.js');
require('./rules/no-extra-semi.js');
require('./rules/no-floating-decimal.js');
require('./rules/no-mixed-operators.js');
require('./rules/no-mixed-spaces-and-tabs.js');
require('./rules/no-multi-spaces.js');
require('./rules/no-multiple-empty-lines.js');
require('./rules/no-tabs.js');
require('./rules/no-trailing-spaces.js');
require('./rules/no-whitespace-before-property.js');
require('./rules/nonblock-statement-body-position.js');
require('./rules/object-curly-newline.js');
require('./rules/object-curly-spacing.js');
require('./rules/object-property-newline.js');
require('./rules/one-var-declaration-per-line.js');
require('./rules/operator-linebreak.js');
require('./rules/padded-blocks.js');
require('./rules/padding-line-between-statements.js');
require('./rules/quote-props.js');
require('./rules/quotes.js');
require('./rules/rest-spread-spacing.js');
require('./rules/semi-spacing.js');
require('./rules/semi-style.js');
require('./rules/semi.js');
require('./rules/space-before-blocks.js');
require('./rules/space-before-function-paren.js');
require('./rules/space-in-parens.js');
require('./rules/space-infix-ops.js');
require('./rules/space-unary-ops.js');
require('./rules/spaced-comment.js');
require('./vendor.js');
require('./rules/switch-colon-spacing.js');
require('./rules/template-curly-spacing.js');
require('./rules/template-tag-spacing.js');
require('./rules/type-annotation-spacing.js');
require('./rules/type-generic-spacing.js');
require('./rules/type-named-tuple-spacing.js');
require('./rules/wrap-iife.js');
require('./rules/wrap-regex.js');
require('./rules/yield-star-spacing.js');
var index = Object.assign(plugin, { configs });
var index = Object.assign(configs.plugin, { configs: configs.configs });
module.exports = index;
export { index as default };

26

dist/rules/array-bracket-newline.js

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

'use strict';
import { c as createRule, i as isTokenOnSameLine, a as isCommentToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var arrayBracketNewline = utils.createRule({
var arrayBracketNewline = createRule({
name: "array-bracket-newline",

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

const nextToken = sourceCode.getTokenAfter(token, { includeComments: true });
if (!nextToken || utils.isCommentToken(nextToken))
if (!nextToken || isCommentToken(nextToken))
return null;

@@ -97,3 +95,3 @@ return fixer.removeRange([token.range[1], nextToken.range[0]]);

const previousToken = sourceCode.getTokenBefore(token, { includeComments: true });
if (!previousToken || utils.isCommentToken(previousToken))
if (!previousToken || isCommentToken(previousToken))
return null;

@@ -136,10 +134,10 @@ return fixer.removeRange([previousToken.range[1], token.range[0]]);

if (needsLinebreaks) {
if (utils.isTokenOnSameLine(openBracket, first))
if (isTokenOnSameLine(openBracket, first))
reportRequiredBeginningLinebreak(node, openBracket);
if (utils.isTokenOnSameLine(last, closeBracket))
if (isTokenOnSameLine(last, closeBracket))
reportRequiredEndingLinebreak(node, closeBracket);
} else {
if (!utils.isTokenOnSameLine(openBracket, first))
if (!isTokenOnSameLine(openBracket, first))
reportNoBeginningLinebreak(node, openBracket);
if (!utils.isTokenOnSameLine(last, closeBracket))
if (!isTokenOnSameLine(last, closeBracket))
reportNoEndingLinebreak(node, closeBracket);

@@ -155,2 +153,2 @@ }

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

18

dist/rules/array-bracket-spacing.js

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

'use strict';
import { c as createRule, i as isTokenOnSameLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var arrayBracketSpacing = utils.createRule({
var arrayBracketSpacing = createRule({
name: "array-bracket-spacing",

@@ -128,3 +126,3 @@ package: "js",

const closingBracketMustBeSpaced = lastElement && options.objectsInArraysException && isObjectType(lastElement) || lastElement && options.arraysInArraysException && isArrayType(lastElement) || options.singleElementException && node.elements.length === 1 ? !options.spaced : options.spaced;
if (utils.isTokenOnSameLine(first, second)) {
if (isTokenOnSameLine(first, second)) {
if (openingBracketMustBeSpaced && !sourceCode.isSpaceBetween(first, second))

@@ -135,3 +133,3 @@ reportRequiredBeginningSpace(node, first);

}
if (first !== penultimate && utils.isTokenOnSameLine(penultimate, last)) {
if (first !== penultimate && isTokenOnSameLine(penultimate, last)) {
if (closingBracketMustBeSpaced && !sourceCode.isSpaceBetween(penultimate, last))

@@ -150,2 +148,2 @@ reportRequiredEndingSpace(node, last);

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

32

dist/rules/array-element-newline.js

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

'use strict';
import { c as createRule, b as isCommaToken, i as isTokenOnSameLine, a as isCommentToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var arrayElementNewline = utils.createRule({
var arrayElementNewline = createRule({
name: "array-element-newline",

@@ -80,3 +78,3 @@ package: "js",

const option = providedOption || "always";
if (!option || option === "always" || typeof option === "object" && option.minItems === 0) {
if (option === "always" || typeof option === "object" && option.minItems === 0) {
minItems = 0;

@@ -116,8 +114,8 @@ } else if (option === "never") {

fix(fixer) {
if (utils.isCommentToken(tokenBefore))
if (isCommentToken(tokenBefore))
return null;
if (!utils.isTokenOnSameLine(tokenBefore, token))
if (!isTokenOnSameLine(tokenBefore, token))
return fixer.replaceTextRange([tokenBefore.range[1], token.range[0]], " ");
const twoTokensBefore = sourceCode.getTokenBefore(tokenBefore, { includeComments: true });
if (utils.isCommentToken(twoTokensBefore))
if (isCommentToken(twoTokensBefore))
return null;

@@ -157,6 +155,6 @@ return fixer.replaceTextRange([twoTokensBefore.range[1], tokenBefore.range[0]], "");

continue;
const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, utils.isCommaToken);
const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, isCommaToken);
const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken);
const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);
if (!utils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
if (!isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
linebreaksCount++;

@@ -169,10 +167,10 @@ }

return;
const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, utils.isCommaToken);
const commaToken = sourceCode.getFirstTokenBetween(previousElement, element, isCommaToken);
const lastTokenOfPreviousElement = sourceCode.getTokenBefore(commaToken);
const firstTokenOfCurrentElement = sourceCode.getTokenAfter(commaToken);
if (needsLinebreaks) {
if (utils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
if (isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
reportRequiredLineBreak(firstTokenOfCurrentElement);
} else {
if (!utils.isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
if (!isTokenOnSameLine(lastTokenOfPreviousElement, firstTokenOfCurrentElement))
reportNoLineBreak(firstTokenOfCurrentElement);

@@ -189,2 +187,2 @@ }

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

20

dist/rules/arrow-parens.js

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

'use strict';
import { c as createRule, d as canTokensBeAdjacent, e as isOpeningParenToken, f as isClosingParenToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function hasBlockBody(node) {
return node.body.type === "BlockStatement";
}
var arrowParens = utils.createRule({
var arrowParens = createRule({
name: "arrow-parens",

@@ -49,3 +47,3 @@ package: "js",

const tokenBeforeParams = sourceCode.getTokenBefore(node.params[0]);
if (tokenBeforeParams && utils.isOpeningParenToken(tokenBeforeParams) && node.range[0] <= tokenBeforeParams.range[0]) {
if (tokenBeforeParams && isOpeningParenToken(tokenBeforeParams) && node.range[0] <= tokenBeforeParams.range[0]) {
return tokenBeforeParams;

@@ -56,3 +54,3 @@ }

function getClosingParenOfParams(node) {
return sourceCode.getTokenAfter(node.params[0], utils.isClosingParenToken);
return sourceCode.getTokenAfter(node.params[0], isClosingParenToken);
}

@@ -91,3 +89,3 @@ function hasCommentsInParensOfParams(node, openingParen) {

const closingParen = getClosingParenOfParams(node);
if (tokenBeforeOpeningParen && tokenBeforeOpeningParen.range[1] === openingParen.range[0] && !utils.canTokensBeAdjacent(tokenBeforeOpeningParen, sourceCode.getFirstToken(param))) {
if (tokenBeforeOpeningParen && tokenBeforeOpeningParen.range[1] === openingParen.range[0] && !canTokensBeAdjacent(tokenBeforeOpeningParen, sourceCode.getFirstToken(param))) {
yield fixer.insertTextBefore(openingParen, " ");

@@ -105,2 +103,2 @@ }

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

16

dist/rules/arrow-spacing.js

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

'use strict';
import { c as createRule, g as isArrowToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var arrowSpacing = utils.createRule({
var arrowSpacing = createRule({
name: "arrow-spacing",

@@ -46,3 +44,3 @@ package: "js",

function getTokens(node) {
const arrow = sourceCode.getTokenBefore(node.body, utils.isArrowToken);
const arrow = sourceCode.getTokenBefore(node.body, isArrowToken);
return {

@@ -111,2 +109,2 @@ before: sourceCode.getTokenBefore(arrow),

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

32

dist/rules/block-spacing.js

@@ -1,11 +0,9 @@

'use strict';
import { c as createRule, i as isTokenOnSameLine, h 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';
import 'estraverse';
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');
require('estraverse');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "block-spacing",

@@ -42,3 +40,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;
}

@@ -110,4 +108,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",

@@ -133,7 +131,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;
}

@@ -149,6 +147,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;

@@ -215,2 +213,2 @@ if (!isValid(openBrace, firstToken)) {

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

48

dist/rules/brace-style.js

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

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

@@ -58,4 +56,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({

@@ -70,3 +68,3 @@ node: openingCurly,

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

@@ -78,3 +76,3 @@ node: openingCurly,

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

@@ -86,3 +84,3 @@ node: openingCurly,

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

@@ -97,3 +95,3 @@ node: closingCurly,

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

@@ -105,3 +103,3 @@ node: curlyToken,

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

@@ -116,3 +114,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));

@@ -150,4 +148,4 @@ },

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

@@ -169,3 +167,3 @@ package: "ts",

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

@@ -176,3 +174,3 @@ const isAllmanStyle = style === "allman";

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

@@ -183,3 +181,3 @@ }

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

@@ -203,3 +201,3 @@ node: openingCurlyToken,

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

@@ -211,3 +209,3 @@ node: openingCurlyToken,

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

@@ -219,3 +217,3 @@ node: openingCurlyToken,

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

@@ -247,2 +245,2 @@ node: closingCurlyToken,

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

40

dist/rules/comma-dangle.js

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

'use strict';
import { c as createRule, b as isCommaToken, j as getNextLocation, h 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';
import 'estraverse';
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');
require('estraverse');
const DEFAULT_OPTIONS = Object.freeze({

@@ -48,3 +46,3 @@ arrays: "never",

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

@@ -132,3 +130,3 @@ package: "js",

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

@@ -156,3 +154,3 @@ return sourceCode.getLastToken(lastItem);

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

@@ -188,3 +186,3 @@ node: lastItem,

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

@@ -311,3 +309,3 @@ messageId: "missing",

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

@@ -334,3 +332,3 @@ "always-multiline",

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

@@ -406,7 +404,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);

@@ -428,7 +426,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({

@@ -446,3 +444,3 @@ node,

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

@@ -476,2 +474,2 @@ node,

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

32

dist/rules/comma-spacing.js

@@ -1,11 +0,9 @@

'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';
import 'estraverse';
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');
require('estraverse');
var commaSpacing = utils.createRule({
var commaSpacing = createRule({
name: "comma-spacing",

@@ -57,3 +55,3 @@ package: "ts",

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

@@ -71,3 +69,3 @@ } else {

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

@@ -77,3 +75,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({

@@ -91,3 +89,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({

@@ -112,3 +110,3 @@ node: commaToken,

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

@@ -119,4 +117,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
);

@@ -129,2 +127,2 @@ });

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

44

dist/rules/comma-style.js

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

'use strict';
import { c as createRule, k as isOpeningBracketToken, b as isCommaToken, l as isNotCommaToken, i as isTokenOnSameLine, m as isNotOpeningParenToken, n as isNotClosingParenToken, L as LINEBREAK_MATCHER } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var commaStyle = utils.createRule({
var commaStyle = createRule({
name: "comma-style",

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

case "between":
return `,${text.replace(utils.LINEBREAK_MATCHER, "")}`;
return `,${text.replace(LINEBREAK_MATCHER, "")}`;
case "first":

@@ -74,5 +72,5 @@ return `${text},`;

function validateCommaItemSpacing(tokenBeforeComma, commaToken, tokenAfterComma) {
if (utils.isTokenOnSameLine(commaToken, tokenAfterComma) && utils.isTokenOnSameLine(tokenBeforeComma, commaToken)) ; else if (!utils.isTokenOnSameLine(commaToken, tokenAfterComma) && !utils.isTokenOnSameLine(tokenBeforeComma, commaToken)) {
if (isTokenOnSameLine(commaToken, tokenAfterComma) && isTokenOnSameLine(tokenBeforeComma, commaToken)) ; else if (!isTokenOnSameLine(commaToken, tokenAfterComma) && !isTokenOnSameLine(tokenBeforeComma, commaToken)) {
const comment = sourceCode.getCommentsAfter(commaToken)[0];
const styleType = comment && comment.type === "Block" && utils.isTokenOnSameLine(commaToken, comment) ? style : "between";
const styleType = comment && comment.type === "Block" && isTokenOnSameLine(commaToken, comment) ? style : "between";
context.report({

@@ -83,3 +81,3 @@ node: commaToken,

});
} else if (style === "first" && !utils.isTokenOnSameLine(commaToken, tokenAfterComma)) {
} else if (style === "first" && !isTokenOnSameLine(commaToken, tokenAfterComma)) {
context.report({

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

});
} else if (style === "last" && utils.isTokenOnSameLine(commaToken, tokenAfterComma)) {
} else if (style === "last" && isTokenOnSameLine(commaToken, tokenAfterComma)) {
context.report({

@@ -105,3 +103,3 @@ node: commaToken,

if (definedItems.length === 0) {
return sourceCode.getTokens(node).filter(utils.isCommaToken);
return sourceCode.getTokens(node).filter(isCommaToken);
}

@@ -112,5 +110,5 @@ const commaTokens = [];

while (prevToken && node.range[0] <= prevToken.range[0]) {
if (utils.isCommaToken(prevToken)) {
if (isCommaToken(prevToken)) {
commaTokens.unshift(prevToken);
} else if (utils.isNotOpeningParenToken(prevToken)) {
} else if (isNotOpeningParenToken(prevToken)) {
break;

@@ -124,7 +122,7 @@ }

commaTokens.push(
...sourceCode.getTokensBetween(prevItem, item).filter(utils.isCommaToken)
...sourceCode.getTokensBetween(prevItem, item).filter(isCommaToken)
);
}
const tokenLastItem = sourceCode.getLastToken(item);
if (tokenLastItem && utils.isCommaToken(tokenLastItem)) {
if (tokenLastItem && isCommaToken(tokenLastItem)) {
commaTokens.push(tokenLastItem);

@@ -136,5 +134,5 @@ }

while (nextToken && nextToken.range[1] <= node.range[1]) {
if (utils.isCommaToken(nextToken)) {
if (isCommaToken(nextToken)) {
commaTokens.push(nextToken);
} else if (utils.isNotClosingParenToken(nextToken)) {
} else if (isNotClosingParenToken(nextToken)) {
break;

@@ -151,9 +149,9 @@ }

const tokenAfterComma = sourceCode.getTokenAfter(commaToken);
if (utils.isOpeningBracketToken(tokenBeforeComma)) {
if (isOpeningBracketToken(tokenBeforeComma)) {
return;
}
if (utils.isCommaToken(tokenBeforeComma) && utils.isOpeningBracketToken(sourceCode.getTokenBefore(tokenBeforeComma, utils.isNotCommaToken))) {
if (isCommaToken(tokenBeforeComma) && isOpeningBracketToken(sourceCode.getTokenBefore(tokenBeforeComma, isNotCommaToken))) {
return;
}
if (utils.isCommaToken(tokenAfterComma) && !utils.isTokenOnSameLine(commaToken, tokenAfterComma)) {
if (isCommaToken(tokenAfterComma) && !isTokenOnSameLine(commaToken, tokenAfterComma)) {
return;

@@ -301,2 +299,2 @@ }

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

26

dist/rules/computed-property-spacing.js

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

'use strict';
import { c as createRule, k as isOpeningBracketToken, o as isClosingBracketToken, i as isTokenOnSameLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var computedPropertySpacing = utils.createRule({
var computedPropertySpacing = createRule({
name: "computed-property-spacing",

@@ -101,9 +99,9 @@ package: "js",

const property = node[propertyName];
const before = sourceCode.getTokenBefore(property, utils.isOpeningBracketToken);
const before = sourceCode.getTokenBefore(property, isOpeningBracketToken);
const first = sourceCode.getTokenAfter(before, { includeComments: true });
const after = sourceCode.getTokenAfter(property, utils.isClosingBracketToken);
const after = sourceCode.getTokenAfter(property, isClosingBracketToken);
const last = sourceCode.getTokenBefore(after, { includeComments: true });
if (utils.isTokenOnSameLine(before, first)) {
if (isTokenOnSameLine(before, first)) {
if (propertyNameMustBeSpaced) {
if (!sourceCode.isSpaceBetween(before, first) && utils.isTokenOnSameLine(before, first))
if (!sourceCode.isSpaceBetween(before, first) && isTokenOnSameLine(before, first))
reportRequiredBeginningSpace(node, before);

@@ -115,5 +113,5 @@ } else {

}
if (utils.isTokenOnSameLine(last, after)) {
if (isTokenOnSameLine(last, after)) {
if (propertyNameMustBeSpaced) {
if (!sourceCode.isSpaceBetween(last, after) && utils.isTokenOnSameLine(last, after))
if (!sourceCode.isSpaceBetween(last, after) && isTokenOnSameLine(last, after))
reportRequiredEndingSpace(node, after);

@@ -139,2 +137,2 @@ } else {

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

26

dist/rules/curly-newline.js

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

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

@@ -89,3 +87,3 @@ multiline: {

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

@@ -156,8 +154,8 @@ package: "plus",

const needsLineBreaks = elementCount >= options.minElements || options.multiline && elementCount > 0 && first.loc.start.line !== last.loc.end.line;
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({

@@ -174,3 +172,3 @@ messageId: "expectedLinebreakAfterOpeningBrace",

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

@@ -189,4 +187,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) {

@@ -285,2 +283,2 @@ context.report({

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

20

dist/rules/dot-location.js

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

'use strict';
import { c as createRule, i as isTokenOnSameLine, q as isDecimalIntegerNumericToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var dotLocation = utils.createRule({
var dotLocation = createRule({
name: "dot-location",

@@ -37,3 +35,3 @@ package: "js",

const tokenBeforeDot = sourceCode.getTokenBefore(dotToken);
if (tokenBeforeDot && !utils.isTokenOnSameLine(tokenBeforeDot, dotToken)) {
if (tokenBeforeDot && !isTokenOnSameLine(tokenBeforeDot, dotToken)) {
context.report({

@@ -44,3 +42,3 @@ node,

*fix(fixer) {
if (dotToken.value.startsWith(".") && utils.isDecimalIntegerNumericToken(tokenBeforeDot))
if (dotToken.value.startsWith(".") && isDecimalIntegerNumericToken(tokenBeforeDot))
yield fixer.insertTextAfter(tokenBeforeDot, ` ${dotToken.value}`);

@@ -53,3 +51,3 @@ else

}
} else if (!utils.isTokenOnSameLine(dotToken, property) && dotToken) {
} else if (!isTokenOnSameLine(dotToken, property) && dotToken) {
context.report({

@@ -76,2 +74,2 @@ node,

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

14

dist/rules/eol-last.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var eolLast = utils.createRule({
var eolLast = createRule({
name: "eol-last",

@@ -84,2 +82,2 @@ package: "js",

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

14

dist/rules/function-call-argument-newline.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var functionCallArgumentNewline = utils.createRule({
var functionCallArgumentNewline = createRule({
name: "function-call-argument-newline",

@@ -93,2 +91,2 @@ package: "js",

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

26

dist/rules/function-call-spacing.js

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

'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';
import 'estraverse';
var utils = require('../utils.js');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var functionCallSpacing = utils.createRule({
var functionCallSpacing = createRule({
name: "function-call-spacing",

@@ -77,6 +75,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") {

@@ -128,3 +126,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, " ");

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

closingParenToken,
astUtils.isOpeningParenToken
isOpeningParenToken
);

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

openingParenToken,
astUtils.isNotOptionalChainPunctuator
isNotOptionalChainPunctuator
);

@@ -204,2 +202,2 @@ checkSpacing(node, lastCalleeToken, openingParenToken);

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

32

dist/rules/function-paren-newline.js

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

'use strict';
import { c as createRule, r as isFunction, i as isTokenOnSameLine, e as isOpeningParenToken, f as isClosingParenToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var functionParenNewline = utils.createRule({
var functionParenNewline = createRule({
name: "function-paren-newline",

@@ -72,4 +70,4 @@ package: "js",

const tokenBeforeRightParen = sourceCode.getTokenBefore(rightParen);
const hasLeftNewline = !utils.isTokenOnSameLine(leftParen, tokenAfterLeftParen);
const hasRightNewline = !utils.isTokenOnSameLine(tokenBeforeRightParen, rightParen);
const hasLeftNewline = !isTokenOnSameLine(leftParen, tokenAfterLeftParen);
const hasRightNewline = !isTokenOnSameLine(tokenBeforeRightParen, rightParen);
const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);

@@ -110,3 +108,3 @@ if (hasLeftNewline && !needsNewlines) {

const tokenAfterLeftParen = sourceCode.getTokenAfter(leftParen);
const hasLeftNewline = !utils.isTokenOnSameLine(leftParen, tokenAfterLeftParen);
const hasLeftNewline = !isTokenOnSameLine(leftParen, tokenAfterLeftParen);
const needsNewlines = shouldHaveNewlines(elements, hasLeftNewline);

@@ -134,3 +132,3 @@ for (let i = 0; i <= elements.length - 2; i++) {

typeParameterOpeningLevel -= 1;
return typeParameterOpeningLevel !== 0 ? false : utils.isOpeningParenToken(token);
return typeParameterOpeningLevel !== 0 ? false : isOpeningParenToken(token);
};

@@ -140,3 +138,3 @@ };

case "NewExpression":
if (!node.arguments.length && !(utils.isOpeningParenToken(sourceCode.getLastToken(node, { skip: 1 })) && utils.isClosingParenToken(sourceCode.getLastToken(node)) && node.callee.range[1] < node.range[1])) {
if (!node.arguments.length && !(isOpeningParenToken(sourceCode.getLastToken(node, { skip: 1 })) && isClosingParenToken(sourceCode.getLastToken(node)) && node.callee.range[1] < node.range[1])) {
return null;

@@ -153,3 +151,3 @@ }

const leftParen = sourceCode.getFirstToken(node, isOpeningParenTokenOutsideTypeParameter());
const rightParen = node.params.length ? sourceCode.getTokenAfter(node.params[node.params.length - 1], utils.isClosingParenToken) : sourceCode.getTokenAfter(leftParen);
const rightParen = node.params.length ? sourceCode.getTokenAfter(node.params[node.params.length - 1], isClosingParenToken) : sourceCode.getTokenAfter(leftParen);
return { leftParen, rightParen };

@@ -159,6 +157,6 @@ }

const firstToken = sourceCode.getFirstToken(node, { skip: node.async ? 1 : 0 });
if (!utils.isOpeningParenToken(firstToken)) {
if (!isOpeningParenToken(firstToken)) {
return null;
}
const rightParen = node.params.length ? sourceCode.getTokenAfter(node.params[node.params.length - 1], utils.isClosingParenToken) : sourceCode.getTokenAfter(firstToken);
const rightParen = node.params.length ? sourceCode.getTokenAfter(node.params[node.params.length - 1], isClosingParenToken) : sourceCode.getTokenAfter(firstToken);
return {

@@ -191,3 +189,3 @@ leftParen: firstToken,

params = [node.source, ...node.options ? [node.options] : []];
else if (utils.isFunction(node))
else if (isFunction(node))
params = node.params;

@@ -206,2 +204,2 @@ else

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

14

dist/rules/generator-star-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const OVERRIDE_SCHEMA = {

@@ -24,3 +22,3 @@ oneOf: [

};
var generatorStarSpacing = utils.createRule({
var generatorStarSpacing = createRule({
name: "generator-star-spacing",

@@ -137,2 +135,2 @@ package: "js",

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

18

dist/rules/implicit-arrow-linebreak.js

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

'use strict';
import { c as createRule, m as isNotOpeningParenToken, a as isCommentToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var implicitArrowLinebreak = utils.createRule({
var implicitArrowLinebreak = createRule({
name: "implicit-arrow-linebreak",

@@ -34,3 +32,3 @@ package: "js",

return;
const arrowToken = sourceCode.getTokenBefore(node.body, utils.isNotOpeningParenToken);
const arrowToken = sourceCode.getTokenBefore(node.body, isNotOpeningParenToken);
const firstTokenOfBody = sourceCode.getTokenAfter(arrowToken);

@@ -48,3 +46,3 @@ if (arrowToken.loc.end.line === firstTokenOfBody.loc.start.line && option === "below") {

fix(fixer) {
if (sourceCode.getFirstTokenBetween(arrowToken, firstTokenOfBody, { includeComments: true, filter: utils.isCommentToken }))
if (sourceCode.getFirstTokenBetween(arrowToken, firstTokenOfBody, { includeComments: true, filter: isCommentToken }))
return null;

@@ -62,2 +60,2 @@ return fixer.replaceTextRange([arrowToken.range[1], firstTokenOfBody.range[0]], " ");

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

16

dist/rules/indent-binary-ops.js

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

'use strict';
import { c as createRule, A as ASSIGNMENT_OPERATOR } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var indentBinaryOps = utils.createRule({
var indentBinaryOps = createRule({
name: "indent-binary-ops",

@@ -107,3 +105,3 @@ package: "plus",

const lastTokenOfLineLeft = lastTokenOfLine(tokenLeft.loc.start.line);
const needAdditionIndent = firstTokenOfLineLeft?.type === "Keyword" && !["typeof", "instanceof", "this"].includes(firstTokenOfLineLeft.value) || firstTokenOfLineLeft?.type === "Identifier" && firstTokenOfLineLeft.value === "type" && isTypeKeywordOfNode(firstTokenOfLineLeft, node) || [":", "[", "(", "<"].concat(utils.ASSIGNMENT_OPERATOR).includes(lastTokenOfLineLeft?.value || "") || ["[", "(", "=>", ":"].concat(utils.ASSIGNMENT_OPERATOR).includes(tokenBeforeAll?.value || "") && firstTokenOfLineLeft?.loc.start.line === tokenBeforeAll?.loc.start.line;
const needAdditionIndent = firstTokenOfLineLeft?.type === "Keyword" && !["typeof", "instanceof", "this"].includes(firstTokenOfLineLeft.value) || firstTokenOfLineLeft?.type === "Identifier" && firstTokenOfLineLeft.value === "type" && isTypeKeywordOfNode(firstTokenOfLineLeft, node) || [":", "[", "(", "<"].concat(ASSIGNMENT_OPERATOR).includes(lastTokenOfLineLeft?.value || "") || ["[", "(", "=>", ":"].concat(ASSIGNMENT_OPERATOR).includes(tokenBeforeAll?.value || "") && firstTokenOfLineLeft?.loc.start.line === tokenBeforeAll?.loc.start.line;
const needSubtractionIndent = lastTokenOfLineLeft?.value === ")" && isGreaterThanCloseBracketOfLine(tokenLeft.loc.start.line) && !["]", ")", "}"].includes(firstTokenOfLineLeft?.value || "");

@@ -166,2 +164,2 @@ const indentLeft = getIndentOfLine(tokenLeft.loc.start.line);

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

14

dist/rules/jsx-child-element-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const INLINE_ELEMENTS = /* @__PURE__ */ new Set([

@@ -44,3 +42,3 @@ "a",

};
var jsxChildElementSpacing = utils.createRule({
var jsxChildElementSpacing = createRule({
name: "jsx-child-element-spacing",

@@ -97,2 +95,2 @@ package: "jsx",

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

14

dist/rules/jsx-closing-bracket-location.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {
bracketLocation: "The closing bracket must be {{location}}{{details}}"
};
var jsxClosingBracketLocation = utils.createRule({
var jsxClosingBracketLocation = createRule({
name: "jsx-closing-bracket-location",

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

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

18

dist/rules/jsx-closing-tag-location.js

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

'use strict';
import { c as createRule, B as isNodeFirstInLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {

@@ -18,3 +16,3 @@ onOwnLine: "Closing tag of a multiline JSX expression must be on its own line.",

};
var jsxClosingTagLocation = utils.createRule({
var jsxClosingTagLocation = createRule({
name: "jsx-closing-tag-location",

@@ -69,3 +67,3 @@ package: "jsx",

}
const messageId = utils.isNodeFirstInLine(context, node) ? MESSAGE_LOCATION[option] : "onOwnLine";
const messageId = isNodeFirstInLine(context, node) ? MESSAGE_LOCATION[option] : "onOwnLine";
context.report({

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

const indent = new Array((getIndentation(openingStartOfLine, opening) || 0) + 1).join(" ");
if (utils.isNodeFirstInLine(context, node)) {
if (isNodeFirstInLine(context, node)) {
return fixer.replaceTextRange(

@@ -96,2 +94,2 @@ [node.range[0] - node.loc.start.column, node.range[0]],

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

34

dist/rules/jsx-curly-brace-presence.js

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

'use strict';
import { c as createRule, C as isJSX, D as isWhiteSpaces } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const OPTION_ALWAYS = "always";

@@ -21,3 +19,3 @@ const OPTION_NEVER = "never";

};
var jsxCurlyBracePresence = utils.createRule({
var jsxCurlyBracePresence = createRule({
name: "jsx-curly-brace-presence",

@@ -89,3 +87,3 @@ package: "jsx",

const value = child.expression.value;
return value ? utils.isWhiteSpaces(value) : false;
return value ? isWhiteSpaces(value) : false;
}

@@ -124,3 +122,3 @@ return false;

let textToReplace;
if (utils.isJSX(expression)) {
if (isJSX(expression)) {
const sourceCode = context.sourceCode;

@@ -132,3 +130,3 @@ textToReplace = sourceCode.getText(expression);

textToReplace = `"${expression.type === "TemplateLiteral" ? expression.quasis[0].value.raw : expression.raw.slice(1, -1)}"`;
} else if (utils.isJSX(expression)) {
} else if (isJSX(expression)) {
const sourceCode = context.sourceCode;

@@ -149,3 +147,3 @@ textToReplace = sourceCode.getText(expression);

fix(fixer) {
if (utils.isJSX(literalNode))
if (isJSX(literalNode))
return fixer.replaceText(literalNode, `{${context.sourceCode.getText(literalNode)}}`);

@@ -163,3 +161,3 @@ if (containsOnlyHtmlEntities(literalNode.raw) || literalNode.parent.type === "JSXAttribute" && containsLineTerminators(literalNode.raw) || isLineBreak(literalNode.raw)) {

function isWhiteSpaceLiteral(node) {
return node.type && node.type === "Literal" && node.value && utils.isWhiteSpaces(node.value);
return node.type && node.type === "Literal" && node.value && isWhiteSpaces(node.value);
}

@@ -178,7 +176,7 @@ function isStringWithTrailingWhiteSpaces(value) {

return;
if ((expressionType === "Literal" || expressionType === "JSXText") && typeof expression.value === "string" && (JSXExpressionNode.parent.type === "JSXAttribute" && !isWhiteSpaceLiteral(expression) || !isLiteralWithTrailingWhiteSpaces(expression)) && !containsMultilineComment(expression.value) && !needToEscapeCharacterForJSX(expression.raw, JSXExpressionNode) && (utils.isJSX(JSXExpressionNode.parent) || !containsQuoteCharacters(expression.value))) {
if ((expressionType === "Literal" || expressionType === "JSXText") && typeof expression.value === "string" && (JSXExpressionNode.parent.type === "JSXAttribute" && !isWhiteSpaceLiteral(expression) || !isLiteralWithTrailingWhiteSpaces(expression)) && !containsMultilineComment(expression.value) && !needToEscapeCharacterForJSX(expression.raw, JSXExpressionNode) && (isJSX(JSXExpressionNode.parent) || !containsQuoteCharacters(expression.value))) {
reportUnnecessaryCurly(JSXExpressionNode);
} else if (expressionType === "TemplateLiteral" && expression.expressions.length === 0 && !expression.quasis[0].value.raw.includes("\n") && !isStringWithTrailingWhiteSpaces(expression.quasis[0].value.raw) && !needToEscapeCharacterForJSX(expression.quasis[0].value.raw, JSXExpressionNode) && !containsQuoteCharacters(expression.quasis[0].value.cooked)) {
reportUnnecessaryCurly(JSXExpressionNode);
} else if (utils.isJSX(expression)) {
} else if (isJSX(expression)) {
reportUnnecessaryCurly(JSXExpressionNode);

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

function areRuleConditionsSatisfied(parent, config, ruleCondition) {
return parent.type === "JSXAttribute" && typeof config.props === "string" && config.props === ruleCondition || utils.isJSX(parent) && typeof config.children === "string" && config.children === ruleCondition;
return parent.type === "JSXAttribute" && typeof config.props === "string" && config.props === ruleCondition || isJSX(parent) && typeof config.children === "string" && config.children === ruleCondition;
}

@@ -222,3 +220,3 @@ function getAdjacentSiblings(node, children) {

}
if (utils.isJSX(parent) && hasAdjacentJsxExpressionContainers(node, parent.children))
if (isJSX(parent) && hasAdjacentJsxExpressionContainers(node, parent.children))
return false;

@@ -233,3 +231,3 @@ if (containsWhitespaceExpression(node) && hasAdjacentJsx(node, parent.children))

function shouldCheckForMissingCurly(node, config) {
if (utils.isJSX(node))
if (isJSX(node))
return config.propElementValues !== OPTION_IGNORE;

@@ -262,2 +260,2 @@ if (isLineBreak(node.raw) || containsOnlyHtmlEntities(node.raw)) {

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

14

dist/rules/jsx-curly-newline.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function getNormalizedOption(context) {

@@ -33,3 +31,3 @@ const rawOption = context.options[0] || "consistent";

};
var jsxCurlyNewline = utils.createRule({
var jsxCurlyNewline = createRule({
name: "jsx-curly-newline",

@@ -141,2 +139,2 @@ package: "jsx",

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

14

dist/rules/jsx-curly-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const SPACING = {

@@ -21,3 +19,3 @@ always: "always",

};
var jsxCurlySpacing = utils.createRule({
var jsxCurlySpacing = createRule({
name: "jsx-curly-spacing",

@@ -306,2 +304,2 @@ package: "jsx",

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

14

dist/rules/jsx-equals-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {

@@ -14,3 +12,3 @@ noSpaceBefore: "There should be no space before '='",

};
var jsxEqualsSpacing = utils.createRule({
var jsxEqualsSpacing = createRule({
name: "jsx-equals-spacing",

@@ -92,2 +90,2 @@ package: "jsx",

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

14

dist/rules/jsx-first-prop-new-line.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {

@@ -12,3 +10,3 @@ propOnNewLine: "Property should be placed on a new line",

};
var jsxFirstPropNewLine = utils.createRule({
var jsxFirstPropNewLine = createRule({
name: "jsx-first-prop-new-line",

@@ -67,2 +65,2 @@ package: "jsx",

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

16

dist/rules/jsx-function-call-newline.js

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

'use strict';
import { c as createRule, C as isJSX } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {

@@ -16,3 +14,3 @@ missingLineBreak: "Missing line break around JSX"

}
var jsxFunctionCallNewline = utils.createRule({
var jsxFunctionCallNewline = createRule({
name: "jsx-function-call-newline",

@@ -52,3 +50,3 @@ package: "jsx",

function check(node) {
if (!node || !utils.isJSX(node))
if (!node || !isJSX(node))
return;

@@ -94,2 +92,2 @@ const sourceCode = context.sourceCode;

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

16

dist/rules/jsx-indent-props.js

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

'use strict';
import { c as createRule, B as isNodeFirstInLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {
wrongIndent: "Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}."
};
var jsxIndentProps = utils.createRule({
var jsxIndentProps = createRule({
name: "jsx-indent-props",

@@ -107,3 +105,3 @@ package: "jsx",

}
if (node.type !== "ArrayExpression" && node.type !== "ObjectExpression" && nodeIndent !== nestedIndent && utils.isNodeFirstInLine(context, node)) {
if (node.type !== "ArrayExpression" && node.type !== "ObjectExpression" && nodeIndent !== nestedIndent && isNodeFirstInLine(context, node)) {
context.report({

@@ -149,2 +147,2 @@ node,

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

22

dist/rules/jsx-indent.js

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

'use strict';
import { c as createRule, C as isJSX, E as isReturningJSX, B as isNodeFirstInLine, F as getFirstNodeInLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {
wrongIndent: "Expected indentation of {{needed}} {{type}} {{characters}} but found {{gotten}}."
};
var jsxIndent = utils.createRule({
var jsxIndent = createRule({
name: "jsx-indent",

@@ -150,3 +148,3 @@ package: "jsx",

const isCorrectAlternateInCondExp = isAlternateInConditionalExp(node) && nodeIndent - indent === 0;
if (nodeIndent !== indent && utils.isNodeFirstInLine(context, node) && !isCorrectRightInLogicalExp && !isCorrectAlternateInCondExp) {
if (nodeIndent !== indent && isNodeFirstInLine(context, node) && !isCorrectRightInLogicalExp && !isCorrectAlternateInCondExp) {
report(node, indent, nodeIndent);

@@ -201,3 +199,3 @@ }

const lastToken = context.sourceCode.getLastToken(node.value);
const firstInLine = utils.getFirstNodeInLine(context, lastToken);
const firstInLine = getFirstNodeInLine(context, lastToken);
if (firstInLine.loc.start.line !== lastToken.loc.start.line)

@@ -231,3 +229,3 @@ return;

ReturnStatement(node) {
if (!node.parent || !node.argument || !utils.isJSX(node.argument)) {
if (!node.parent || !node.argument || !isJSX(node.argument)) {
return;

@@ -238,3 +236,3 @@ }

fn = fn.parent;
if (!fn || !utils.isReturningJSX(node, context, true)) {
if (!fn || !isReturningJSX(node, context, true)) {
return;

@@ -251,2 +249,2 @@ }

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

14

dist/rules/jsx-max-props-per-line.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function getPropName(context, propNode) {

@@ -16,3 +14,3 @@ if (propNode.type === "JSXSpreadAttribute")

};
var jsxMaxPropsPerLine = utils.createRule({
var jsxMaxPropsPerLine = createRule({
name: "jsx-max-props-per-line",

@@ -125,2 +123,2 @@ package: "jsx",

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

14

dist/rules/jsx-newline.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {

@@ -16,3 +14,3 @@ require: "JSX element should start in a new line",

}
var jsxNewline = utils.createRule({
var jsxNewline = createRule({
name: "jsx-newline",

@@ -133,2 +131,2 @@ package: "jsx",

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

20

dist/rules/jsx-one-expression-per-line.js

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

'use strict';
import { c as createRule, D as isWhiteSpaces } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const optionDefaults = {

@@ -14,3 +12,3 @@ allow: "none"

};
var jsxOneExpressionPerLine = utils.createRule({
var jsxOneExpressionPerLine = createRule({
name: "jsx-one-expression-per-line",

@@ -90,3 +88,3 @@ package: "jsx",

if (child.type === "Literal" || child.type === "JSXText") {
if (utils.isWhiteSpaces(child.raw))
if (isWhiteSpaces(child.raw))
return;

@@ -132,7 +130,7 @@ countNewLinesBeforeContent = (child.raw.match(/^\s*\n/g) || []).length;

const tokenBetweenNodes = context.sourceCode.getTokensBetween(prevChild, child)[0];
return (prevChild.type === "Literal" || prevChild.type === "JSXText") && prevChild.raw.endsWith(" ") || (child.type === "Literal" || child.type === "JSXText") && child.raw.startsWith(" ") || utils.isWhiteSpaces(tokenBetweenNodes?.value);
return (prevChild.type === "Literal" || prevChild.type === "JSXText") && prevChild.raw.endsWith(" ") || (child.type === "Literal" || child.type === "JSXText") && child.raw.startsWith(" ") || isWhiteSpaces(tokenBetweenNodes?.value);
};
const spaceBetweenNext = () => {
const tokenBetweenNodes = context.sourceCode.getTokensBetween(child, nextChild)[0];
return (nextChild.type === "Literal" || nextChild.type === "JSXText") && nextChild.raw.startsWith(" ") || (child.type === "Literal" || child.type === "JSXText") && child.raw.endsWith(" ") || utils.isWhiteSpaces(tokenBetweenNodes?.value);
return (nextChild.type === "Literal" || nextChild.type === "JSXText") && nextChild.raw.startsWith(" ") || (child.type === "Literal" || child.type === "JSXText") && child.raw.endsWith(" ") || isWhiteSpaces(tokenBetweenNodes?.value);
};

@@ -191,2 +189,2 @@ const source = context.sourceCode.getText(child);

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

20

dist/rules/jsx-pascal-case.js

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

'use strict';
import { c as createRule, G as isDOMComponent, H as getElementType } from '../utils.js';
import picomatch from 'picomatch';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
var picomatch = require('picomatch');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function testDigit(char) {

@@ -53,3 +51,3 @@ const charCode = char.charCodeAt(0);

};
var jsxPascalCase = utils.createRule({
var jsxPascalCase = createRule({
name: "jsx-pascal-case",

@@ -101,6 +99,6 @@ package: "jsx",

JSXOpeningElement(node) {
const isCompatTag = utils.isDOMComponent(node);
const isCompatTag = isDOMComponent(node);
if (isCompatTag)
return;
const name = utils.getElementType(node);
const name = getElementType(node);
let checkNames = [name];

@@ -138,2 +136,2 @@ let index = 0;

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

14

dist/rules/jsx-props-no-multi-spaces.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {

@@ -12,3 +10,3 @@ noLineGap: "Expected no line gap between \u201C{{prop1}}\u201D and \u201C{{prop2}}\u201D",

};
var jsxPropsNoMultiSpaces = utils.createRule({
var jsxPropsNoMultiSpaces = createRule({
name: "jsx-props-no-multi-spaces",

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

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

18

dist/rules/jsx-quotes.js

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

'use strict';
import { c as createRule, I as isStringLiteral, J as isSurroundedBy } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const QUOTE_SETTINGS = {

@@ -24,3 +22,3 @@ "prefer-double": {

};
var jsxQuotes = utils.createRule({
var jsxQuotes = createRule({
name: "jsx-quotes",

@@ -48,3 +46,3 @@ package: "js",

function usesExpectedQuotes(node) {
return node.value.includes(setting.quote) || utils.isSurroundedBy(node.raw, setting.quote);
return node.value.includes(setting.quote) || isSurroundedBy(node.raw, setting.quote);
}

@@ -54,3 +52,3 @@ return {

const attributeValue = node.value;
if (attributeValue && utils.isStringLiteral(attributeValue) && !usesExpectedQuotes(attributeValue)) {
if (attributeValue && isStringLiteral(attributeValue) && !usesExpectedQuotes(attributeValue)) {
context.report({

@@ -72,2 +70,2 @@ node: attributeValue,

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

18

dist/rules/jsx-self-closing-comp.js

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

'use strict';
import { c as createRule, G as isDOMComponent } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const optionDefaults = { component: true, html: true };

@@ -12,3 +10,3 @@ const messages = {

};
var jsxSelfClosingComp = utils.createRule({
var jsxSelfClosingComp = createRule({
name: "jsx-self-closing-comp",

@@ -42,3 +40,3 @@ package: "jsx",

function isComponent(node) {
return node.name && (node.name.type === "JSXIdentifier" || node.name.type === "JSXMemberExpression") && !utils.isDOMComponent(node);
return node.name && (node.name.type === "JSXIdentifier" || node.name.type === "JSXMemberExpression") && !isDOMComponent(node);
}

@@ -54,3 +52,3 @@ function childrenIsEmpty(node) {

const configuration = Object.assign({}, optionDefaults, context.options[0]);
return (configuration.component && isComponent(node) || configuration.html && utils.isDOMComponent(node)) && !node.selfClosing && (childrenIsEmpty(node) || childrenIsMultilineSpaces(node));
return (configuration.component && isComponent(node) || configuration.html && isDOMComponent(node)) && !node.selfClosing && (childrenIsEmpty(node) || childrenIsMultilineSpaces(node));
}

@@ -76,2 +74,2 @@ return {

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

28

dist/rules/jsx-sort-props.js

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

'use strict';
import { c as createRule, G as isDOMComponent, K as getPropName } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function isCallbackPropName(name) {

@@ -40,4 +38,4 @@ return /^on[A-Z]/.test(name);

function contextCompare(a, b, options) {
let aProp = utils.getPropName(a);
let bProp = utils.getPropName(b);
let aProp = getPropName(a);
let bProp = getPropName(b);
const aSortToEnd = shouldSortToEnd(a);

@@ -83,3 +81,3 @@ const bSortToEnd = shouldSortToEnd(b);

return 0;
const actualLocale = options.locale === "auto" ? undefined : options.locale;
const actualLocale = options.locale === "auto" ? void 0 : options.locale;
if (options.ignoreCase) {

@@ -246,3 +244,3 @@ aProp = aProp.toLowerCase();

}
var jsxSortProps = utils.createRule({
var jsxSortProps = createRule({
name: "jsx-sort-props",

@@ -314,8 +312,8 @@ package: "jsx",

JSXOpeningElement(node) {
const nodeReservedList = reservedFirst && !utils.isDOMComponent(node) ? reservedList.filter((prop) => prop !== "dangerouslySetInnerHTML") : reservedList;
const nodeReservedList = reservedFirst && !isDOMComponent(node) ? reservedList.filter((prop) => prop !== "dangerouslySetInnerHTML") : reservedList;
node.attributes.reduce((memo, decl, idx, attrs) => {
if (decl.type === "JSXSpreadAttribute")
return attrs[idx + 1];
let previousPropName = utils.getPropName(memo);
let currentPropName = utils.getPropName(decl);
let previousPropName = getPropName(memo);
let currentPropName = getPropName(decl);
const previousValue = memo.value;

@@ -387,3 +385,3 @@ const currentValue = decl.value;

}
if (!noSortAlphabetically && (ignoreCase || locale !== "auto" ? previousPropName.localeCompare(currentPropName, locale === "auto" ? undefined : locale) > 0 : previousPropName > currentPropName)) {
if (!noSortAlphabetically && (ignoreCase || locale !== "auto" ? previousPropName.localeCompare(currentPropName, locale === "auto" ? void 0 : locale) > 0 : previousPropName > currentPropName)) {
reportNodeAttribute(decl, "sortPropsByAlpha", node, context, nodeReservedList);

@@ -399,2 +397,2 @@ return memo;

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

18

dist/rules/jsx-tag-spacing.js

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

'use strict';
import { c as createRule, M as getTokenBeforeClosingBracket } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const messages = {

@@ -89,3 +87,3 @@ selfCloseSlashNoSpace: "Whitespace is forbidden between `/` and `>`; write `/>`",

const sourceCode = context.sourceCode;
const leftToken = utils.getTokenBeforeClosingBracket(node);
const leftToken = getTokenBeforeClosingBracket(node);
const closingSlash = sourceCode.getTokenAfter(leftToken);

@@ -168,3 +166,3 @@ if (node.loc.start.line !== node.loc.end.line && option === "proportional-always") {

const sourceCode = context.sourceCode;
const leftToken = option === "proportional-always" ? utils.getTokenBeforeClosingBracket(node) : sourceCode.getLastTokens(node, 2)[0];
const leftToken = option === "proportional-always" ? getTokenBeforeClosingBracket(node) : sourceCode.getLastTokens(node, 2)[0];
const closingToken = sourceCode.getTokenAfter(leftToken);

@@ -232,3 +230,3 @@ if (node.loc.start.line !== node.loc.end.line && option === "proportional-always") {

};
var jsxTagSpacing = utils.createRule({
var jsxTagSpacing = createRule({
name: "jsx-tag-spacing",

@@ -294,2 +292,2 @@ package: "jsx",

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

24

dist/rules/jsx-wrap-multilines.js

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

'use strict';
import { c as createRule, C as isJSX, N as isParenthesized } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const DEFAULTS = {

@@ -22,3 +20,3 @@ declaration: "parens",

};
var jsxWrapMultilines = utils.createRule({
var jsxWrapMultilines = createRule({
name: "jsx-wrap-multilines",

@@ -86,3 +84,3 @@ package: "jsx",

const previousToken = context.sourceCode.getTokenBefore(node);
if (!utils.isParenthesized(node, context.sourceCode))
if (!isParenthesized(node, context.sourceCode))
return false;

@@ -95,3 +93,3 @@ if (previousToken.loc.end.line === node.loc.start.line)

const nextToken = context.sourceCode.getTokenAfter(node);
if (!utils.isParenthesized(node, context.sourceCode))
if (!isParenthesized(node, context.sourceCode))
return false;

@@ -110,7 +108,7 @@ if (node.loc.end.line === nextToken.loc.end.line)

function check(node, type) {
if (!node || !utils.isJSX(node))
if (!node || !isJSX(node))
return;
const sourceCode = context.sourceCode;
const option = getOption(type);
if ((option === true || option === "parens") && !utils.isParenthesized(node, context.sourceCode) && isMultilines(node)) {
if ((option === true || option === "parens") && !isParenthesized(node, context.sourceCode) && isMultilines(node)) {
context.report({

@@ -123,3 +121,3 @@ node,

if (option === "parens-new-line" && isMultilines(node)) {
if (!utils.isParenthesized(node, context.sourceCode)) {
if (!isParenthesized(node, context.sourceCode)) {
const tokenBefore = sourceCode.getTokenBefore(node);

@@ -244,2 +242,2 @@ const tokenAfter = sourceCode.getTokenAfter(node);

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

50

dist/rules/key-spacing.js

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

'use strict';
import { c as createRule, w as isColonToken, O as getStaticPropertyName, P as getStringLength, u as isOpeningBraceToken, x as isClosingBraceToken, L as LINEBREAK_MATCHER, h 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';
import 'estraverse';
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');
require('estraverse');
const listeningNodes = [

@@ -21,3 +19,3 @@ "ObjectExpression",

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

@@ -31,4 +29,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;

@@ -87,3 +85,3 @@ }

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

@@ -297,3 +295,3 @@ package: "js",

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

@@ -327,3 +325,3 @@ function getLastTokenBeforeColon(node) {

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

@@ -385,3 +383,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]));
}

@@ -517,5 +515,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",

@@ -541,3 +539,3 @@ package: "ts",

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

@@ -547,7 +545,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;
}

@@ -558,3 +556,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);

@@ -566,3 +564,3 @@ const code = sourceCode.getText(node);

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

@@ -573,3 +571,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;

@@ -713,3 +711,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 = [];

@@ -724,3 +722,3 @@ let unalignedElements = [];

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

@@ -761,2 +759,2 @@ currentAlignGroup.push(node);

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

54

dist/rules/keyword-spacing.js

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

'use strict';
import { Q as KEYWORDS_JS, c as createRule, m as isNotOpeningParenToken, i as isTokenOnSameLine, R as isKeywordToken, h as castRuleModule, T as deepMerge, U as nullThrows, V as NullThrowsReasons } from '../utils.js';
import { AST_NODE_TYPES, AST_TOKEN_TYPES } from '@typescript-eslint/utils';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const PREV_TOKEN = /^[)\]}>]$/u;

@@ -16,3 +14,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() {

@@ -31,3 +29,3 @@ KEYS.sort();

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

@@ -78,3 +76,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({

@@ -93,3 +91,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({

@@ -108,3 +106,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({

@@ -123,3 +121,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({

@@ -184,3 +182,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)

@@ -215,3 +213,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);

@@ -229,3 +227,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);

@@ -343,3 +341,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);

@@ -351,5 +349,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,

@@ -366,3 +364,3 @@ {

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

@@ -388,3 +386,3 @@ package: "ts",

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

@@ -394,6 +392,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);

@@ -404,3 +402,3 @@ asToken.type = oldTokenType;

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

@@ -410,6 +408,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);

@@ -422,3 +420,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;

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

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

16

dist/rules/line-comment-position.js

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

'use strict';
import { c as createRule, W as COMMENTS_IGNORE_PATTERN } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var lineCommentPosition = utils.createRule({
var lineCommentPosition = createRule({
name: "line-comment-position",

@@ -67,3 +65,3 @@ package: "js",

}
const defaultIgnoreRegExp = utils.COMMENTS_IGNORE_PATTERN;
const defaultIgnoreRegExp = COMMENTS_IGNORE_PATTERN;
const fallThroughRegExp = /^\s*falls?\s?through/u;

@@ -102,2 +100,2 @@ const sourceCode = context.sourceCode;

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

16

dist/rules/linebreak-style.js

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

'use strict';
import { c as createRule, z as createGlobalLinebreakMatcher } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var linebreakStyle = utils.createRule({
var linebreakStyle = createRule({
name: "linebreak-style",

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

const source = sourceCode.getText();
const pattern = utils.createGlobalLinebreakMatcher();
const pattern = createGlobalLinebreakMatcher();
let match;

@@ -72,2 +70,2 @@ let i = 0;

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

72

dist/rules/lines-around-comment.js

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

'use strict';
import { c as createRule, W as COMMENTS_IGNORE_PATTERN$1, a as isCommentToken, i as isTokenOnSameLine, u as isOpeningBraceToken, h 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';
import 'estraverse';
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');
require('estraverse');
function getEmptyLineNums$1(lines) {

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

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

@@ -104,3 +102,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");

@@ -120,4 +118,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;

@@ -127,4 +125,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;

@@ -152,3 +150,3 @@ return false;

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

@@ -216,3 +214,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;

@@ -228,3 +226,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({

@@ -270,3 +268,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;

@@ -289,3 +287,3 @@ function getEmptyLineNums(lines) {

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

@@ -406,4 +404,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;

@@ -415,4 +413,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;

@@ -441,24 +439,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);
}

@@ -496,3 +494,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;

@@ -508,3 +506,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({

@@ -521,3 +519,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))

@@ -545,3 +543,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) {

@@ -553,3 +551,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) {

@@ -568,2 +566,2 @@ checkForEmptyLine(token, {

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

28

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

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

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

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

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

@@ -81,3 +79,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 };

@@ -118,3 +116,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;

@@ -155,5 +153,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 },

@@ -172,3 +170,3 @@ {

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

@@ -197,3 +195,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;
}

@@ -209,2 +207,2 @@ return {

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

14

dist/rules/max-len.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const OPTIONS_SCHEMA = {

@@ -56,3 +54,3 @@ type: "object",

};
var maxLen = utils.createRule({
var maxLen = createRule({
name: "max-len",

@@ -242,2 +240,2 @@ package: "js",

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

16

dist/rules/max-statements-per-line.js

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

'use strict';
import { c as createRule, y as isNotSemicolonToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const listeningNodes = [

@@ -33,3 +31,3 @@ "BreakStatement",

];
var maxStatementsPerLine = utils.createRule({
var maxStatementsPerLine = createRule({
name: "max-statements-per-line",

@@ -90,3 +88,3 @@ package: "js",

function getActualLastToken(node) {
return sourceCode.getLastToken(node, utils.isNotSemicolonToken);
return sourceCode.getLastToken(node, isNotSemicolonToken);
}

@@ -129,2 +127,2 @@ function enterStatement(node) {

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

24

dist/rules/member-delimiter-style.js

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

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

@@ -66,3 +64,3 @@ const positionInLine = token.loc.start.column;

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

@@ -138,7 +136,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,

@@ -217,3 +215,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;

@@ -225,3 +223,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" };

@@ -239,2 +237,2 @@ members.forEach((member, index) => {

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

26

dist/rules/multiline-comment-style.js

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

'use strict';
import { c as createRule, W as COMMENTS_IGNORE_PATTERN, L as LINEBREAK_MATCHER } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var multilineCommentStyle = utils.createRule({
var multilineCommentStyle = createRule({
name: "multiline-comment-style",

@@ -71,3 +69,3 @@ package: "js",

return false;
const lines = firstComment.value.split(utils.LINEBREAK_MATCHER);
const lines = firstComment.value.split(LINEBREAK_MATCHER);
return lines.length > 0 && lines.every((line, i) => (i === 0 || i === lines.length - 1 ? /^\s*$/u : /^\s*\*/u).test(line));

@@ -78,3 +76,3 @@ }

return false;
const lines = firstComment.value.split(utils.LINEBREAK_MATCHER);
const lines = firstComment.value.split(LINEBREAK_MATCHER);
return /^\*\s*$/u.test(lines[0]) && lines.slice(1, -1).every((line) => /^\s* /u.test(line)) && /^\s*$/u.test(lines.at(-1));

@@ -87,3 +85,3 @@ }

function processStarredBlockComment(comment) {
const lines = comment.value.split(utils.LINEBREAK_MATCHER).filter((line, i, linesArr) => !(i === 0 || i === linesArr.length - 1)).map((line) => line.replace(/^\s*$/u, ""));
const lines = comment.value.split(LINEBREAK_MATCHER).filter((line, i, linesArr) => !(i === 0 || i === linesArr.length - 1)).map((line) => line.replace(/^\s*$/u, ""));
const allLinesHaveLeadingSpace = lines.map((line) => line.replace(/\s*\*/u, "")).filter((line) => line.trim().length).every((line) => line.startsWith(" "));

@@ -93,3 +91,3 @@ return lines.map((line) => line.replace(allLinesHaveLeadingSpace ? /\s*\* ?/u : /\s*\*/u, ""));

function processBareBlockComment(comment) {
const lines = comment.value.split(utils.LINEBREAK_MATCHER).map((line) => line.replace(/^\s*$/u, ""));
const lines = comment.value.split(LINEBREAK_MATCHER).map((line) => line.replace(/^\s*$/u, ""));
const leadingWhitespace = `${sourceCode.text.slice(comment.range[0] - comment.loc.start.column, comment.range[0])} `;

@@ -161,3 +159,3 @@ let offset = "";

} else {
const lines = firstComment.value.split(utils.LINEBREAK_MATCHER);
const lines = firstComment.value.split(LINEBREAK_MATCHER);
const expectedLeadingWhitespace = getInitialOffset(firstComment);

@@ -283,3 +281,3 @@ const expectedLinePrefix = `${expectedLeadingWhitespace} *`;

Program() {
return sourceCode.getAllComments().filter((comment) => comment.type !== "Shebang").filter((comment) => !utils.COMMENTS_IGNORE_PATTERN.test(comment.value)).filter((comment) => {
return sourceCode.getAllComments().filter((comment) => comment.type !== "Shebang").filter((comment) => !COMMENTS_IGNORE_PATTERN.test(comment.value)).filter((comment) => {
const tokenBefore = sourceCode.getTokenBefore(comment, { includeComments: true });

@@ -301,2 +299,2 @@ return !tokenBefore || tokenBefore.loc.end.line < comment.loc.start.line;

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

30

dist/rules/multiline-ternary.js

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

'use strict';
import { c as createRule, n as isNotClosingParenToken, i as isTokenOnSameLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var multilineTernary = utils.createRule({
var multilineTernary = createRule({
name: "multiline-ternary",

@@ -46,4 +44,4 @@ package: "js",

ConditionalExpression(node) {
const questionToken = sourceCode.getTokenAfter(node.test, utils.isNotClosingParenToken);
const colonToken = sourceCode.getTokenAfter(node.consequent, utils.isNotClosingParenToken);
const questionToken = sourceCode.getTokenAfter(node.test, isNotClosingParenToken);
const colonToken = sourceCode.getTokenAfter(node.consequent, isNotClosingParenToken);
const firstTokenOfTest = sourceCode.getFirstToken(node);

@@ -54,4 +52,4 @@ const lastTokenOfTest = sourceCode.getTokenBefore(questionToken);

const firstTokenOfAlternate = sourceCode.getTokenAfter(colonToken);
const areTestAndConsequentOnSameLine = utils.isTokenOnSameLine(lastTokenOfTest, firstTokenOfConsequent);
const areConsequentAndAlternateOnSameLine = utils.isTokenOnSameLine(lastTokenOfConsequent, firstTokenOfAlternate);
const areTestAndConsequentOnSameLine = isTokenOnSameLine(lastTokenOfTest, firstTokenOfConsequent);
const areConsequentAndAlternateOnSameLine = isTokenOnSameLine(lastTokenOfConsequent, firstTokenOfAlternate);
const hasComments = !!sourceCode.getCommentsInside(node).length;

@@ -76,4 +74,4 @@ if (IGNORE_JSX) {

const fixers = [];
const areTestAndQuestionOnSameLine = utils.isTokenOnSameLine(lastTokenOfTest, questionToken);
const areQuestionAndConsOnSameLine = utils.isTokenOnSameLine(questionToken, firstTokenOfConsequent);
const areTestAndQuestionOnSameLine = isTokenOnSameLine(lastTokenOfTest, questionToken);
const areQuestionAndConsOnSameLine = isTokenOnSameLine(questionToken, firstTokenOfConsequent);
if (!areTestAndQuestionOnSameLine)

@@ -99,4 +97,4 @@ fixers.push(fixer.removeRange([lastTokenOfTest.range[1], questionToken.range[0]]));

const fixers = [];
const areConsAndColonOnSameLine = utils.isTokenOnSameLine(lastTokenOfConsequent, colonToken);
const areColonAndAltOnSameLine = utils.isTokenOnSameLine(colonToken, firstTokenOfAlternate);
const areConsAndColonOnSameLine = isTokenOnSameLine(lastTokenOfConsequent, colonToken);
const areColonAndAltOnSameLine = isTokenOnSameLine(colonToken, firstTokenOfAlternate);
if (!areConsAndColonOnSameLine)

@@ -153,2 +151,2 @@ fixers.push(fixer.removeRange([lastTokenOfConsequent.range[1], colonToken.range[0]]));

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

18

dist/rules/new-parens.js

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

'use strict';
import { c as createRule, f as isClosingParenToken, e as isOpeningParenToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var newParens = utils.createRule({
var newParens = createRule({
name: "new-parens",

@@ -37,5 +35,5 @@ package: "js",

const lastToken = sourceCode.getLastToken(node);
const hasLastParen = lastToken && utils.isClosingParenToken(lastToken);
const hasLastParen = lastToken && isClosingParenToken(lastToken);
const tokenBeforeLastToken = sourceCode.getTokenBefore(lastToken);
const hasParens = hasLastParen && utils.isOpeningParenToken(tokenBeforeLastToken) && node.callee.range[1] < node.range[1];
const hasParens = hasLastParen && isOpeningParenToken(tokenBeforeLastToken) && node.callee.range[1] < node.range[1];
if (always) {

@@ -68,2 +66,2 @@ if (!hasParens) {

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

28

dist/rules/newline-per-chained-call.js

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

'use strict';
import { c as createRule, X as skipChainExpression, i as isTokenOnSameLine, n as isNotClosingParenToken, L as LINEBREAK_MATCHER } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var newlinePerChainedCall = utils.createRule({
var newlinePerChainedCall = createRule({
name: "newline-per-chained-call",

@@ -49,3 +47,3 @@ package: "js",

const prefix = getPrefix(node);
const lines = sourceCode.getText(node.property).split(utils.LINEBREAK_MATCHER);
const lines = sourceCode.getText(node.property).split(LINEBREAK_MATCHER);
const suffix = node.computed && lines.length === 1 ? "]" : "";

@@ -56,16 +54,16 @@ return prefix + lines[0] + suffix;

"CallExpression:exit": function(node) {
const callee = utils.skipChainExpression(node.callee);
const callee = skipChainExpression(node.callee);
if (callee.type !== "MemberExpression")
return;
let parent = utils.skipChainExpression(callee.object);
let parent = skipChainExpression(callee.object);
let depth = 1;
while (parent && "callee" in parent && parent.callee) {
depth += 1;
const parentCallee = utils.skipChainExpression(parent.callee);
const parentCallee = skipChainExpression(parent.callee);
if (!("object" in parentCallee))
break;
parent = utils.skipChainExpression(parentCallee.object);
parent = skipChainExpression(parentCallee.object);
}
if (depth > ignoreChainWithDepth && utils.isTokenOnSameLine(callee.object, callee.property)) {
const firstTokenAfterObject = sourceCode.getTokenAfter(callee.object, utils.isNotClosingParenToken);
if (depth > ignoreChainWithDepth && isTokenOnSameLine(callee.object, callee.property)) {
const firstTokenAfterObject = sourceCode.getTokenAfter(callee.object, isNotClosingParenToken);
context.report({

@@ -91,2 +89,2 @@ node: callee.property,

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

18

dist/rules/no-confusing-arrow.js

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

'use strict';
import { c as createRule, Y as isParenthesised } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function isConditional(node) {
return node.type === "ConditionalExpression";
}
var noConfusingArrow = utils.createRule({
var noConfusingArrow = createRule({
name: "no-confusing-arrow",

@@ -34,3 +32,3 @@ package: "js",

const config = context.options[0] || {};
const allowParens = config.allowParens || config.allowParens === undefined;
const allowParens = config.allowParens || config.allowParens === void 0;
const onlyOneSimpleParam = config.onlyOneSimpleParam;

@@ -40,3 +38,3 @@ const sourceCode = context.sourceCode;

const body = node.body;
if (isConditional(body) && !(allowParens && utils.isParenthesised(sourceCode, body)) && !(onlyOneSimpleParam && !(node.params.length === 1 && node.params[0].type === "Identifier"))) {
if (isConditional(body) && !(allowParens && isParenthesised(sourceCode, body)) && !(onlyOneSimpleParam && !(node.params.length === 1 && node.params[0].type === "Identifier"))) {
context.report({

@@ -57,2 +55,2 @@ node,

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

166

dist/rules/no-extra-parens.js

@@ -1,11 +0,9 @@

'use strict';
import { c as createRule, Z as getPrecedence, _ as isDecimalInteger, m as isNotOpeningParenToken, k as isOpeningBracketToken, n as isNotClosingParenToken, e as isOpeningParenToken, u as isOpeningBraceToken, X as skipChainExpression, O as getStaticPropertyName, N as isParenthesized, f as isClosingParenToken, $ as isMixedLogicalAndCoalesceExpressions, d as canTokensBeAdjacent, a0 as isTopLevelExpressionStatement, h 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';
import 'estraverse';
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');
require('estraverse');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "no-extra-parens",

@@ -69,3 +67,3 @@ package: "js",

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

@@ -87,7 +85,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));
}

@@ -116,6 +114,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);
}

@@ -151,3 +149,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];
}

@@ -183,3 +181,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);
}

@@ -191,6 +189,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";

@@ -206,3 +204,3 @@ }

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

@@ -278,3 +276,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);

@@ -284,3 +282,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);

@@ -303,6 +301,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);

@@ -319,3 +317,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.");

@@ -406,5 +404,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);

@@ -450,5 +448,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)
)) {

@@ -465,3 +463,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") {

@@ -483,5 +481,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)
)) {

@@ -544,3 +542,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);

@@ -677,4 +675,4 @@ }

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

@@ -698,4 +696,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)

@@ -708,3 +706,3 @@ return;

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

@@ -718,3 +716,3 @@ });

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

@@ -727,3 +725,3 @@ });

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

@@ -733,7 +731,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({

@@ -744,3 +742,3 @@ ...node,

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

@@ -754,3 +752,3 @@ ]

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

@@ -760,3 +758,3 @@ ...node,

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

@@ -772,3 +770,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
)

@@ -778,3 +776,3 @@ });

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

@@ -784,3 +782,3 @@ },

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

@@ -790,3 +788,3 @@ ...node,

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

@@ -800,3 +798,3 @@ });

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

@@ -806,3 +804,3 @@ ...node,

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

@@ -814,3 +812,3 @@ });

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

@@ -820,3 +818,3 @@ ...node,

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

@@ -828,3 +826,3 @@ });

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

@@ -834,7 +832,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({

@@ -844,7 +842,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({

@@ -854,3 +852,3 @@ ...node,

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

@@ -864,3 +862,3 @@ });

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

@@ -871,3 +869,3 @@ ...node,

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

@@ -878,3 +876,3 @@ ...node,

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

@@ -888,3 +886,3 @@ ...node,

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

@@ -895,3 +893,3 @@ },

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

@@ -901,7 +899,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({

@@ -911,3 +909,3 @@ ...node,

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

@@ -923,7 +921,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);

@@ -933,3 +931,3 @@ },

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

@@ -939,3 +937,3 @@ },

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

@@ -947,9 +945,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
}

@@ -963,7 +961,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;

@@ -974,9 +972,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
}

@@ -990,3 +988,3 @@ });

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

@@ -999,2 +997,2 @@ }

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

26

dist/rules/no-extra-semi.js

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

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

@@ -29,3 +27,3 @@ package: "js",

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

@@ -36,8 +34,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);

@@ -84,4 +82,4 @@ }

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

@@ -111,2 +109,2 @@ package: "ts",

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

16

dist/rules/no-floating-decimal.js

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

'use strict';
import { c as createRule, d as canTokensBeAdjacent } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var noFloatingDecimal = utils.createRule({
var noFloatingDecimal = createRule({
name: "no-floating-decimal",

@@ -34,3 +32,3 @@ package: "js",

const tokenBefore = sourceCode.getTokenBefore(node);
const needsSpaceBefore = tokenBefore && tokenBefore.range[1] === node.range[0] && !utils.canTokensBeAdjacent(tokenBefore, `0${node.raw}`);
const needsSpaceBefore = tokenBefore && tokenBefore.range[1] === node.range[0] && !canTokensBeAdjacent(tokenBefore, `0${node.raw}`);
return fixer.insertTextBefore(node, needsSpaceBefore ? " 0" : "0");

@@ -53,2 +51,2 @@ }

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

20

dist/rules/no-mixed-operators.js

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

'use strict';
import { c as createRule, Z as getPrecedence, Y as isParenthesised, n as isNotClosingParenToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const ARITHMETIC_OPERATORS = ["+", "-", "*", "/", "%", "**"];

@@ -47,3 +45,3 @@ const BITWISE_OPERATORS = ["&", "|", "^", "~", "<<", ">>", ">>>"];

}
var noMixedOperators = utils.createRule({
var noMixedOperators = createRule({
name: "no-mixed-operators",

@@ -95,9 +93,9 @@ package: "js",

b.type === "ConditionalExpression" ? "?:" : b.operator
) || options.allowSamePrecedence && utils.getPrecedence(a) === utils.getPrecedence(b);
) || options.allowSamePrecedence && getPrecedence(a) === getPrecedence(b);
}
function isMixedWithParent(node) {
return node.operator !== node.parent.operator && !utils.isParenthesised(sourceCode, node);
return node.operator !== node.parent.operator && !isParenthesised(sourceCode, node);
}
function getOperatorToken(node) {
return sourceCode.getTokenAfter(getChildNode(node), utils.isNotClosingParenToken);
return sourceCode.getTokenAfter(getChildNode(node), isNotClosingParenToken);
}

@@ -137,2 +135,2 @@ function reportBothOperators(node) {

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

14

dist/rules/no-mixed-spaces-and-tabs.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var noMixedSpacesAndTabs = utils.createRule({
var noMixedSpacesAndTabs = createRule({
name: "no-mixed-spaces-and-tabs",

@@ -89,2 +87,2 @@ package: "js",

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

16

dist/rules/no-multi-spaces.js

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

'use strict';
import { c as createRule, a as isCommentToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var noMultiSpaces = utils.createRule({
var noMultiSpaces = createRule({
name: "no-multi-spaces",

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

}
if (ignoreEOLComments && utils.isCommentToken(rightToken) && (leftIndex === tokensAndComments.length - 2 || rightToken.loc.end.line < tokensAndComments[leftIndex + 2].loc.start.line)) {
if (ignoreEOLComments && isCommentToken(rightToken) && (leftIndex === tokensAndComments.length - 2 || rightToken.loc.end.line < tokensAndComments[leftIndex + 2].loc.start.line)) {
return;

@@ -97,2 +95,2 @@ }

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

14

dist/rules/no-multiple-empty-lines.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var noMultipleEmptyLines = utils.createRule({
var noMultipleEmptyLines = createRule({
name: "no-multiple-empty-lines",

@@ -107,2 +105,2 @@ package: "js",

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

14

dist/rules/no-tabs.js

@@ -1,11 +0,9 @@

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const tabRegex = /\t+/gu;
const anyNonWhitespaceRegex = /\S/u;
var noTabs = utils.createRule({
var noTabs = createRule({
name: "no-tabs",

@@ -63,2 +61,2 @@ package: "js",

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

16

dist/rules/no-trailing-spaces.js

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

'use strict';
import { c as createRule, z as createGlobalLinebreakMatcher } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var noTrailingSpaces = utils.createRule({
var noTrailingSpaces = createRule({
name: "no-trailing-spaces",

@@ -69,3 +67,3 @@ package: "js",

const lines = sourceCode.lines;
const linebreaks = sourceCode.getText().match(utils.createGlobalLinebreakMatcher());
const linebreaks = sourceCode.getText().match(createGlobalLinebreakMatcher());
const comments = sourceCode.getAllComments();

@@ -112,2 +110,2 @@ const commentLineNumbers = getCommentLineNumbers(comments);

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

20

dist/rules/no-whitespace-before-property.js

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

'use strict';
import { c as createRule, i as isTokenOnSameLine, k as isOpeningBracketToken, _ as isDecimalInteger } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var noWhitespaceBeforeProperty = utils.createRule({
var noWhitespaceBeforeProperty = createRule({
name: "no-whitespace-before-property",

@@ -33,3 +31,3 @@ package: "js",

let replacementText = "";
if (!node.computed && !node.optional && utils.isDecimalInteger(node.object)) {
if (!node.computed && !node.optional && isDecimalInteger(node.object)) {
return null;

@@ -51,6 +49,6 @@ }

let leftToken;
if (!utils.isTokenOnSameLine(node.object, node.property))
if (!isTokenOnSameLine(node.object, node.property))
return;
if (node.computed) {
rightToken = sourceCode.getTokenBefore(node.property, utils.isOpeningBracketToken);
rightToken = sourceCode.getTokenBefore(node.property, isOpeningBracketToken);
leftToken = sourceCode.getTokenBefore(rightToken, node.optional ? 1 : 0);

@@ -68,2 +66,2 @@ } else {

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

14

dist/rules/nonblock-statement-body-position.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const POSITION_SCHEMA = {

@@ -12,3 +10,3 @@ type: "string",

};
var nonblockStatementBodyPosition = utils.createRule({
var nonblockStatementBodyPosition = createRule({
name: "nonblock-statement-body-position",

@@ -90,2 +88,2 @@ package: "js",

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

30

dist/rules/object-curly-newline.js

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

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

@@ -85,3 +83,3 @@ oneOf: [

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

@@ -139,8 +137,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({

@@ -157,3 +155,3 @@ messageId: "expectedLinebreakAfterOpeningBrace",

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

@@ -172,4 +170,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) {

@@ -218,5 +216,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",

@@ -246,2 +244,2 @@ package: "ts",

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

56

dist/rules/object-curly-spacing.js

@@ -1,11 +0,9 @@

'use strict';
import { c as createRule, l as isNotCommaToken, i as isTokenOnSameLine, o as isClosingBracketToken, x as isClosingBraceToken, h 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';
import 'estraverse';
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');
require('estraverse');
var _baseRule = utils.createRule(
var _baseRule = createRule(
{

@@ -111,3 +109,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);

@@ -119,4 +117,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;

@@ -133,3 +131,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);
}

@@ -155,3 +153,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 });

@@ -167,3 +165,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 });

@@ -187,4 +185,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",

@@ -266,3 +264,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);

@@ -273,17 +271,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;

@@ -299,3 +297,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);
}

@@ -333,2 +331,2 @@ const rules = baseRule.create(context);

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

18

dist/rules/object-property-newline.js

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

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

@@ -77,4 +75,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",

@@ -116,2 +114,2 @@ package: "ts",

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

14

dist/rules/one-var-declaration-per-line.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var oneVarDeclarationPerLine = utils.createRule({
var oneVarDeclarationPerLine = createRule({
name: "one-var-declaration-per-line",

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

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

26

dist/rules/operator-linebreak.js

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

'use strict';
import { c as createRule, i as isTokenOnSameLine, z as createGlobalLinebreakMatcher } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var operatorLinebreak = utils.createRule({
var operatorLinebreak = createRule({
name: "operator-linebreak",

@@ -66,4 +64,4 @@ package: "js",

const textAfter = sourceCode.text.slice(operatorToken.range[1], tokenAfter.range[0]);
const hasLinebreakBefore = !utils.isTokenOnSameLine(tokenBefore, operatorToken);
const hasLinebreakAfter = !utils.isTokenOnSameLine(operatorToken, tokenAfter);
const hasLinebreakBefore = !isTokenOnSameLine(tokenBefore, operatorToken);
const hasLinebreakAfter = !isTokenOnSameLine(operatorToken, tokenAfter);
let newTextBefore, newTextAfter;

@@ -77,3 +75,3 @@ if (hasLinebreakBefore !== hasLinebreakAfter && desiredStyle !== "none") {

} else {
const LINEBREAK_REGEX = utils.createGlobalLinebreakMatcher();
const LINEBREAK_REGEX = createGlobalLinebreakMatcher();
newTextBefore = desiredStyle === "before" || textBefore.trim() ? textBefore : textBefore.replace(LINEBREAK_REGEX, "");

@@ -97,3 +95,3 @@ newTextAfter = desiredStyle === "after" || textAfter.trim() ? textAfter : textAfter.replace(LINEBREAK_REGEX, "");

const fix = getFixer(operatorToken, style);
if (utils.isTokenOnSameLine(leftToken, operatorToken) && utils.isTokenOnSameLine(operatorToken, rightToken)) ; else if (operatorStyleOverride !== "ignore" && !utils.isTokenOnSameLine(leftToken, operatorToken) && !utils.isTokenOnSameLine(operatorToken, rightToken)) {
if (isTokenOnSameLine(leftToken, operatorToken) && isTokenOnSameLine(operatorToken, rightToken)) ; else if (operatorStyleOverride !== "ignore" && !isTokenOnSameLine(leftToken, operatorToken) && !isTokenOnSameLine(operatorToken, rightToken)) {
context.report({

@@ -108,3 +106,3 @@ node,

});
} else if (style === "before" && utils.isTokenOnSameLine(leftToken, operatorToken)) {
} else if (style === "before" && isTokenOnSameLine(leftToken, operatorToken)) {
context.report({

@@ -119,3 +117,3 @@ node,

});
} else if (style === "after" && utils.isTokenOnSameLine(operatorToken, rightToken)) {
} else if (style === "after" && isTokenOnSameLine(operatorToken, rightToken)) {
context.report({

@@ -165,2 +163,2 @@ node,

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

16

dist/rules/padded-blocks.js

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

'use strict';
import { c as createRule, i as isTokenOnSameLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const OPTION_ENUMS = ["always", "never", "start", "end"];
var paddedBlocks = utils.createRule({
var paddedBlocks = createRule({
name: "padded-blocks",

@@ -128,3 +126,3 @@ package: "js",

const blockHasBottomPadding = isPaddingBetweenTokens(lastBlockToken, tokenAfterLast);
if (exceptOptions.allowSingleLineBlocks && utils.isTokenOnSameLine(tokenBeforeFirst, tokenAfterLast))
if (exceptOptions.allowSingleLineBlocks && isTokenOnSameLine(tokenBeforeFirst, tokenAfterLast))
return;

@@ -218,2 +216,2 @@ const requiredPadding = requirePaddingFor(node);

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

146

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

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

'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';
import 'estraverse';
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');
require('estraverse');
const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u;

@@ -48,14 +46,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);
}

@@ -66,9 +64,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";

@@ -81,3 +79,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;

@@ -87,8 +85,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);
}

@@ -108,10 +106,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");
}

@@ -123,3 +121,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);
}

@@ -130,3 +128,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;

@@ -189,3 +187,3 @@ }

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

@@ -197,3 +195,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);

@@ -220,3 +218,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)
},

@@ -231,22 +229,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
],

@@ -257,21 +255,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": {

@@ -285,11 +283,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"

@@ -301,3 +299,3 @@ ),

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

@@ -373,3 +371,3 @@ package: "ts",

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

@@ -406,10 +404,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)) {

@@ -456,2 +454,2 @@ return;

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

40

dist/rules/quote-props.js

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

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

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

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

@@ -98,3 +96,3 @@ function areQuotesRedundant(rawKey, tokens, skipNumberLiterals = false) {

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

@@ -123,3 +121,3 @@ return;

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

@@ -172,3 +170,3 @@ node,

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

@@ -249,4 +247,4 @@ necessaryQuotes = true;

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

@@ -268,3 +266,3 @@ package: "ts",

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

@@ -279,3 +277,3 @@ method: false,

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

@@ -290,3 +288,3 @@ method: true,

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

@@ -303,3 +301,3 @@ optional: false,

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

@@ -311,3 +309,3 @@ });

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

@@ -320,3 +318,3 @@ });

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

@@ -329,2 +327,2 @@ });

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

56

dist/rules/quotes.js

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

'use strict';
import { a3 as LINEBREAKS, c as createRule, a0 as isTopLevelExpressionStatement, Y as isParenthesised, J as isSurroundedBy, a4 as hasOctalOrNonOctalDecimalEscapeSequence, h as castRuleModule } from '../utils.js';
import { AST_NODE_TYPES } from '@typescript-eslint/utils';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
var utils$1 = require('@typescript-eslint/utils');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function switchQuote(str) {

@@ -44,5 +42,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",

@@ -125,3 +123,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);
}

@@ -131,3 +129,3 @@ function isExpressionInOrJustAfterDirectivePrologue(node) {

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

@@ -153,3 +151,3 @@ const block = node.parent.parent;

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

@@ -199,5 +197,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) {

@@ -211,3 +209,3 @@ context.report({

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

@@ -234,3 +232,3 @@ }

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

@@ -246,4 +244,4 @@ }

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

@@ -274,15 +272,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:

@@ -305,2 +303,2 @@ return false;

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

14

dist/rules/rest-spread-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var restSpreadSpacing = utils.createRule({
var restSpreadSpacing = createRule({
name: "rest-spread-spacing",

@@ -86,2 +84,2 @@ package: "js",

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

26

dist/rules/semi-spacing.js

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

'use strict';
import { c as createRule, s as isSemicolonToken, i as isTokenOnSameLine, x as isClosingBraceToken, f as isClosingParenToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var semiSpacing = utils.createRule({
var semiSpacing = createRule({
name: "semi-spacing",

@@ -51,22 +49,22 @@ package: "js",

const tokenBefore = sourceCode.getTokenBefore(token);
return tokenBefore && utils.isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetween(tokenBefore, token);
return tokenBefore && isTokenOnSameLine(tokenBefore, token) && sourceCode.isSpaceBetween(tokenBefore, token);
}
function hasTrailingSpace(token) {
const tokenAfter = sourceCode.getTokenAfter(token);
return tokenAfter && utils.isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetween(token, tokenAfter);
return tokenAfter && isTokenOnSameLine(token, tokenAfter) && sourceCode.isSpaceBetween(token, tokenAfter);
}
function isLastTokenInCurrentLine(token) {
const tokenAfter = sourceCode.getTokenAfter(token);
return !(tokenAfter && utils.isTokenOnSameLine(token, tokenAfter));
return !(tokenAfter && isTokenOnSameLine(token, tokenAfter));
}
function isFirstTokenInCurrentLine(token) {
const tokenBefore = sourceCode.getTokenBefore(token);
return !(tokenBefore && utils.isTokenOnSameLine(token, tokenBefore));
return !(tokenBefore && isTokenOnSameLine(token, tokenBefore));
}
function isBeforeClosingParen(token) {
const nextToken = sourceCode.getTokenAfter(token);
return nextToken && utils.isClosingBraceToken(nextToken) || utils.isClosingParenToken(nextToken);
return nextToken && isClosingBraceToken(nextToken) || isClosingParenToken(nextToken);
}
function checkSemicolonSpacing(token, node) {
if (utils.isSemicolonToken(token)) {
if (isSemicolonToken(token)) {
if (hasLeadingSpace(token)) {

@@ -162,2 +160,2 @@ if (!requireSpaceBefore) {

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

24

dist/rules/semi-style.js

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

'use strict';
import { c as createRule, s as isSemicolonToken, i as isTokenOnSameLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const SELECTOR = [

@@ -45,3 +43,3 @@ "BreakStatement",

}
var semiStyle = utils.createRule({
var semiStyle = createRule({
name: "semi-style",

@@ -66,4 +64,4 @@ package: "js",

const nextToken = sourceCode.getTokenAfter(semiToken);
const prevIsSameLine = !prevToken || utils.isTokenOnSameLine(prevToken, semiToken);
const nextIsSameLine = !nextToken || utils.isTokenOnSameLine(semiToken, nextToken);
const prevIsSameLine = !prevToken || isTokenOnSameLine(prevToken, semiToken);
const nextIsSameLine = !nextToken || isTokenOnSameLine(semiToken, nextToken);
if (expected === "last" && !prevIsSameLine || expected === "first" && !nextIsSameLine) {

@@ -92,8 +90,8 @@ context.report({

const lastToken = sourceCode.getLastToken(node);
if (utils.isSemicolonToken(lastToken))
if (isSemicolonToken(lastToken))
check(lastToken, option);
},
ForStatement(node) {
const firstSemi = node.init && sourceCode.getTokenAfter(node.init, utils.isSemicolonToken);
const secondSemi = node.test && sourceCode.getTokenAfter(node.test, utils.isSemicolonToken);
const firstSemi = node.init && sourceCode.getTokenAfter(node.init, isSemicolonToken);
const secondSemi = node.test && sourceCode.getTokenAfter(node.test, isSemicolonToken);
if (firstSemi)

@@ -108,2 +106,2 @@ check(firstSemi, "last");

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

48

dist/rules/semi.js

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

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

@@ -84,3 +82,3 @@ package: "js",

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

@@ -94,3 +92,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);
};

@@ -107,6 +105,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;

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

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

@@ -191,3 +189,3 @@ function maybeAsiHazardAfter(node) {

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

@@ -240,4 +238,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",

@@ -267,9 +265,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) => {

@@ -283,3 +281,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);

@@ -291,2 +289,2 @@ }

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

28

dist/rules/space-before-blocks.js

@@ -1,14 +0,12 @@

'use strict';
import { c as createRule, i as isTokenOnSameLine, g as isArrowToken, R as isKeywordToken, w as isColonToken, a5 as getSwitchCaseColonToken, r as isFunction, h as castRuleModule } from '../utils.js';
import { isTokenOnSameLine as isTokenOnSameLine$1 } from '@typescript-eslint/utils/ast-utils';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
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",

@@ -80,7 +78,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);

@@ -135,4 +133,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",

@@ -161,3 +159,3 @@ package: "ts",

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

@@ -202,2 +200,2 @@ precedingToken,

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

26

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

@@ -1,11 +0,9 @@

'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';
import 'estraverse';
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');
require('estraverse');
var spaceBeforeFunctionParen = utils.createRule({
var spaceBeforeFunctionParen = createRule({
name: "space-before-function-paren",

@@ -61,7 +59,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;

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

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

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

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

24

dist/rules/space-in-parens.js

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

'use strict';
import { c as createRule, e as isOpeningParenToken, f as isClosingParenToken, i as isTokenOnSameLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var spaceInParens = utils.createRule({
var spaceInParens = createRule({
name: "space-in-parens",

@@ -97,3 +95,3 @@ package: "js",

return false;
if (!options.empty && utils.isClosingParenToken(tokenAfterOpeningParen))
if (!options.empty && isClosingParenToken(tokenAfterOpeningParen))
return false;

@@ -105,3 +103,3 @@ if (ALWAYS)

function openerRejectsSpace(openingParenToken, tokenAfterOpeningParen) {
if (!utils.isTokenOnSameLine(openingParenToken, tokenAfterOpeningParen))
if (!isTokenOnSameLine(openingParenToken, tokenAfterOpeningParen))
return false;

@@ -119,3 +117,3 @@ if (tokenAfterOpeningParen.type === "Line")

return false;
if (!options.empty && utils.isOpeningParenToken(tokenBeforeClosingParen))
if (!options.empty && isOpeningParenToken(tokenBeforeClosingParen))
return false;

@@ -127,3 +125,3 @@ if (ALWAYS)

function closerRejectsSpace(tokenBeforeClosingParen, closingParenToken) {
if (!utils.isTokenOnSameLine(tokenBeforeClosingParen, closingParenToken))
if (!isTokenOnSameLine(tokenBeforeClosingParen, closingParenToken))
return false;

@@ -143,3 +141,3 @@ if (!sourceCode.isSpaceBetween(tokenBeforeClosingParen, closingParenToken))

const nextToken = tokens[i + 1];
if (!utils.isOpeningParenToken(token) && !utils.isClosingParenToken(token))
if (!isOpeningParenToken(token) && !isClosingParenToken(token))
return;

@@ -192,2 +190,2 @@ if (token.value === "(" && openerMissingSpace(token, nextToken)) {

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

28

dist/rules/space-infix-ops.js

@@ -1,11 +0,9 @@

'use strict';
import { c as createRule, v as isEqToken, h 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';
import 'estraverse';
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');
require('estraverse');
var _baseRule = utils.createRule({
var _baseRule = createRule({
name: "space-infix-ops",

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

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

@@ -117,5 +115,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",

@@ -163,3 +161,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);
}

@@ -190,3 +188,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(

@@ -228,2 +226,2 @@ type,

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

18

dist/rules/space-unary-ops.js

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

'use strict';
import { c as createRule, d as canTokensBeAdjacent } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var spaceUnaryOps = utils.createRule({
var spaceUnaryOps = createRule({
name: "space-unary-ops",

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

function verifyWordDoesntHaveSpaces(node, firstToken, secondToken, word) {
if (utils.canTokensBeAdjacent(firstToken, secondToken)) {
if (canTokensBeAdjacent(firstToken, secondToken)) {
if (secondToken.range[0] > firstToken.range[1]) {

@@ -155,3 +153,3 @@ context.report({

fix(fixer) {
if (utils.canTokensBeAdjacent(firstToken, secondToken))
if (canTokensBeAdjacent(firstToken, secondToken))
return fixer.removeRange([firstToken.range[1], secondToken.range[0]]);

@@ -207,2 +205,2 @@ return null;

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

20

dist/rules/spaced-comment.js

@@ -1,11 +0,9 @@

'use strict';
import { c as createRule, a3 as LINEBREAKS } from '../utils.js';
import { e as escapeStringRegexp } from '../vendor.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
var vendor = require('../vendor.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function escape(s) {
return `(?:${vendor.escapeStringRegexp(s)})`;
return `(?:${escapeStringRegexp(s)})`;
}

@@ -33,3 +31,3 @@ function escapeAndRepeat(s) {

}
pattern += `(?:$|[${Array.from(utils.LINEBREAKS).join("")}]))`;
pattern += `(?:$|[${Array.from(LINEBREAKS).join("")}]))`;
}

@@ -55,3 +53,3 @@ return pattern;

}
var spacedComment = utils.createRule({
var spacedComment = createRule({
name: "spaced-comment",

@@ -234,2 +232,2 @@ package: "js",

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

20

dist/rules/switch-colon-spacing.js

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

'use strict';
import { c as createRule, a5 as getSwitchCaseColonToken, x as isClosingBraceToken, i as isTokenOnSameLine, a as isCommentToken } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var switchColonSpacing = utils.createRule({
var switchColonSpacing = createRule({
name: "switch-colon-spacing",

@@ -40,3 +38,3 @@ package: "js",

function isValidSpacing(left, right, expected) {
return utils.isClosingBraceToken(right) || !utils.isTokenOnSameLine(left, right) || sourceCode.isSpaceBetween(left, right) === expected;
return isClosingBraceToken(right) || !isTokenOnSameLine(left, right) || sourceCode.isSpaceBetween(left, right) === expected;
}

@@ -49,3 +47,3 @@ function commentsExistBetween(left, right) {

includeComments: true,
filter: utils.isCommentToken
filter: isCommentToken
}

@@ -63,3 +61,3 @@ ) !== null;

SwitchCase(node) {
const colonToken = utils.getSwitchCaseColonToken(node, sourceCode);
const colonToken = getSwitchCaseColonToken(node, sourceCode);
const beforeToken = sourceCode.getTokenBefore(colonToken);

@@ -88,2 +86,2 @@ const afterToken = sourceCode.getTokenAfter(colonToken);

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

18

dist/rules/template-curly-spacing.js

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

'use strict';
import { c as createRule, i as isTokenOnSameLine } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var templateCurlySpacing = utils.createRule({
var templateCurlySpacing = createRule({
name: "template-curly-spacing",

@@ -38,3 +36,3 @@ package: "js",

const hasSpace = sourceCode.isSpaceBetween(prevToken, token);
if (!utils.isTokenOnSameLine(prevToken, token))
if (!isTokenOnSameLine(prevToken, token))
return;

@@ -70,3 +68,3 @@ if (always && !hasSpace) {

const hasSpace = sourceCode.isSpaceBetween(token, nextToken);
if (!utils.isTokenOnSameLine(token, nextToken))
if (!isTokenOnSameLine(token, nextToken))
return;

@@ -107,2 +105,2 @@ if (always && !hasSpace) {

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

14

dist/rules/template-tag-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var templateTagSpacing = utils.createRule({
var templateTagSpacing = createRule({
name: "template-tag-spacing",

@@ -73,2 +71,2 @@ package: "js",

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

32

dist/rules/type-annotation-spacing.js

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

'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';
import 'estraverse';
var utils = require('../utils.js');
var astUtils = require('@typescript-eslint/utils/ast-utils');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
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 } : {}
};

@@ -36,5 +34,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;

@@ -45,13 +43,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",

@@ -216,2 +214,2 @@ package: "ts",

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

14

dist/rules/type-generic-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const PRESERVE_PREFIX_SPACE_BEFORE_GENERIC = /* @__PURE__ */ new Set([

@@ -14,3 +12,3 @@ "TSCallSignatureDeclaration",

]);
var typeGenericSpacing = utils.createRule({
var typeGenericSpacing = createRule({
name: "type-generic-spacing",

@@ -154,2 +152,2 @@ package: "plus",

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

14

dist/rules/type-named-tuple-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
const tupleRe = /^([\w$]+)(\s*)(\?\s*)?:(\s*)(.*)$/;
var typeNamedTupleSpacing = utils.createRule({
var typeNamedTupleSpacing = createRule({
name: "type-named-tuple-spacing",

@@ -79,2 +77,2 @@ package: "plus",

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

22

dist/rules/wrap-iife.js

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

'use strict';
import { c as createRule, Y as isParenthesised, N as isParenthesized, X as skipChainExpression, O as getStaticPropertyName } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
function isCalleeOfNewExpression(node) {

@@ -12,3 +10,3 @@ const maybeCallee = node.parent?.type === "ChainExpression" ? node.parent : node;

}
var wrapIife = utils.createRule({
var wrapIife = createRule({
name: "wrap-iife",

@@ -49,12 +47,12 @@ package: "js",

function isWrappedInAnyParens(node) {
return utils.isParenthesised(sourceCode, node);
return isParenthesised(sourceCode, node);
}
function isWrappedInGroupingParens(node) {
return utils.isParenthesized(node, sourceCode, 1);
return isParenthesized(node, sourceCode, 1);
}
function getFunctionNodeFromIIFE(node) {
const callee = utils.skipChainExpression(node.callee);
const callee = skipChainExpression(node.callee);
if (callee.type === "FunctionExpression")
return callee;
if (includeFunctionPrototypeMethods && callee.type === "MemberExpression" && callee.object.type === "FunctionExpression" && (utils.getStaticPropertyName(callee) === "call" || utils.getStaticPropertyName(callee) === "apply")) {
if (includeFunctionPrototypeMethods && callee.type === "MemberExpression" && callee.object.type === "FunctionExpression" && (getStaticPropertyName(callee) === "call" || getStaticPropertyName(callee) === "apply")) {
return callee.object;

@@ -119,2 +117,2 @@ }

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

14

dist/rules/wrap-regex.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var wrapRegex = utils.createRule({
var wrapRegex = createRule({
name: "wrap-regex",

@@ -45,2 +43,2 @@ package: "js",

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

14

dist/rules/yield-star-spacing.js

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

'use strict';
import { c as createRule } from '../utils.js';
import 'eslint-visitor-keys';
import 'espree';
import 'estraverse';
var utils = require('../utils.js');
require('eslint-visitor-keys');
require('espree');
require('estraverse');
var yieldStarSpacing = utils.createRule({
var yieldStarSpacing = createRule({
name: "yield-star-spacing",

@@ -91,2 +89,2 @@ package: "js",

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

100

dist/utils.js

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

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

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

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

@@ -255,3 +246,3 @@

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

@@ -288,3 +279,3 @@ return -1;

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

@@ -296,3 +287,3 @@ };

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

@@ -317,3 +308,3 @@ return false;

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

@@ -507,3 +498,3 @@ return false;

});
estraverse.traverse(ASTnode, opts);
traverse$1(ASTnode, opts);
}

@@ -826,61 +817,2 @@ function traverseReturns(ASTNode, onReturn) {

exports.ASSIGNMENT_OPERATOR = ASSIGNMENT_OPERATOR;
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.getElementType = getElementType;
exports.getFirstNodeInLine = getFirstNodeInLine;
exports.getNextLocation = getNextLocation;
exports.getPrecedence = getPrecedence;
exports.getPropName = getPropName;
exports.getStaticPropertyName = getStaticPropertyName;
exports.getStringLength = getStringLength;
exports.getSwitchCaseColonToken = getSwitchCaseColonToken;
exports.getTokenBeforeClosingBracket = getTokenBeforeClosingBracket;
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.isDOMComponent = isDOMComponent;
exports.isDecimalInteger = isDecimalInteger;
exports.isDecimalIntegerNumericToken = isDecimalIntegerNumericToken;
exports.isEqToken = isEqToken;
exports.isFunction = isFunction;
exports.isJSX = isJSX;
exports.isKeywordToken = isKeywordToken;
exports.isMixedLogicalAndCoalesceExpressions = isMixedLogicalAndCoalesceExpressions;
exports.isNodeFirstInLine = isNodeFirstInLine;
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.isReturningJSX = isReturningJSX;
exports.isSemicolonToken = isSemicolonToken;
exports.isStringLiteral = isStringLiteral;
exports.isSurroundedBy = isSurroundedBy;
exports.isTokenOnSameLine = isTokenOnSameLine;
exports.isTopLevelExpressionStatement = isTopLevelExpressionStatement;
exports.isWhiteSpaces = isWhiteSpaces;
exports.nullThrows = nullThrows;
exports.skipChainExpression = skipChainExpression;
export { isMixedLogicalAndCoalesceExpressions as $, ASSIGNMENT_OPERATOR as A, isNodeFirstInLine as B, isJSX as C, isWhiteSpaces as D, isReturningJSX as E, getFirstNodeInLine as F, isDOMComponent as G, getElementType as H, isStringLiteral as I, isSurroundedBy as J, getPropName as K, LINEBREAK_MATCHER as L, getTokenBeforeClosingBracket as M, isParenthesized as N, getStaticPropertyName as O, getStringLength as P, KEYWORDS_JS as Q, isKeywordToken as R, STATEMENT_LIST_PARENTS as S, deepMerge as T, nullThrows as U, NullThrowsReasons as V, COMMENTS_IGNORE_PATTERN as W, skipChainExpression as X, isParenthesised as Y, getPrecedence as Z, isDecimalInteger as _, isCommentToken as a, isTopLevelExpressionStatement as a0, FixTracker as a1, isNumericLiteral as a2, LINEBREAKS as a3, hasOctalOrNonOctalDecimalEscapeSequence as a4, getSwitchCaseColonToken as a5, isCommaToken as b, createRule as c, canTokensBeAdjacent as d, isOpeningParenToken as e, isClosingParenToken as f, isArrowToken as g, castRuleModule as h, isTokenOnSameLine as i, getNextLocation as j, isOpeningBracketToken as k, isNotCommaToken as l, isNotOpeningParenToken as m, isNotClosingParenToken as n, isClosingBracketToken as o, createAllConfigs as p, isDecimalIntegerNumericToken as q, isFunction as r, isSemicolonToken as s, isQuestionDotToken as t, isOpeningBraceToken as u, isEqToken as v, isColonToken as w, isClosingBraceToken as x, isNotSemicolonToken as y, createGlobalLinebreakMatcher as z };

4

dist/vendor.js

@@ -1,3 +0,1 @@

'use strict';
function escapeStringRegexp(string) {

@@ -15,2 +13,2 @@ if (typeof string !== 'string') {

exports.escapeStringRegexp = escapeStringRegexp;
export { escapeStringRegexp as e };

9

package.json
{
"name": "@stylistic/eslint-plugin",
"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"

@@ -135,6 +134,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",

@@ -141,0 +140,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