npm - @plugjs/eslint-plugin - Versions diffs - 0.2.7 → 0.2.9 - Mend

@plugjs/eslint-plugin 0.2.7 → 0.2.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/bundles/eslint-plugin-import-x.cjs +24 -103
package/bundles/stylistic-eslint-plugin.cjs +641 -359
package/package.json +11 -12

package/bundles/stylistic-eslint-plugin.cjs CHANGED Viewed

@@ -800,10 +800,7 @@ var require_utils = __commonJS({
     Function.call.bind(Object.hasOwnProperty);
     var __defProp = Object.defineProperty;
     var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-    var __publicField = (obj, key, value) => {
-      __defNormalProp(obj, key + "", value);
-      return value;
-    };
+    var __publicField = (obj, key, value) => __defNormalProp(obj, key + "", value);
     var FixTracker = class {
       /**
        * Create a new FixTracker.
@@ -3335,10 +3332,7 @@ var require_indent = __commonJS({
     var utils = require_utils();
     var __defProp = Object.defineProperty;
     var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-    var __publicField = (obj, key, value) => {
-      __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-      return value;
-    };
+    var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
     var KNOWN_NODES = /* @__PURE__ */ new Set([
       "AssignmentExpression",
       "AssignmentPattern",
@@ -3935,7 +3929,7 @@ var require_indent = __commonJS({
         }
         function validateTokenIndent(token, desiredIndent) {
           const indentation = tokenInfo.getTokenIndent(token);
-          return indentation === desiredIndent || indentation.includes(" ") && indentation.includes("	");
+          return indentation === desiredIndent;
         }
         function isOuterIIFE(node) {
           if (!node.parent || node.parent.type !== "CallExpression" || node.parent.callee !== node)
@@ -7293,8 +7287,7 @@ var require_no_extra_parens = __commonJS({
         function checkCallNew(node) {
           const callee = node.callee;
           if (hasExcessParensWithPrecedence(callee, precedence(node))) {
-            if (hasDoubleExcessParens(callee) || !(isIIFE(node) || // @ts-expect-error comment above
-            callee.type === "NewExpression" && !isNewExpressionWithParens(callee) && !(node.type === "NewExpression" && !isNewExpressionWithParens(node)) || node.type === "NewExpression" && callee.type === "MemberExpression" && doesMemberExpressionContainCallExpression(callee) || (!("optional" in node) || !node.optional) && callee.type === "ChainExpression")) {
+            if (hasDoubleExcessParens(callee) || !(isIIFE(node) || callee.type === "NewExpression" && !isNewExpressionWithParens(callee) && !(node.type === "NewExpression" && !isNewExpressionWithParens(node)) || node.type === "NewExpression" && callee.type === "MemberExpression" && doesMemberExpressionContainCallExpression(callee) || (!("optional" in node) || !node.optional) && callee.type === "ChainExpression")) {
               report(node.callee);
             }
           }
@@ -13533,7 +13526,6 @@ var require_jsx_curly_newline = __commonJS({
         type: "layout",
         docs: {
           description: "Enforce consistent linebreaks in curly braces in JSX attributes and expressions",
-          recommended: "stylistic",
           url: utils.docsUrl("jsx-curly-newline")
         },
         fixable: "whitespace",
@@ -14115,8 +14107,7 @@ var require_jsx_function_call_newline = __commonJS({
         type: "layout",
         docs: {
           description: "Enforce line breaks before and after JSX elements when they are used as arguments to a function.",
-          url: utils.docsUrl("jsx-function-call-newline"),
-          recommended: "stylistic"
+          url: utils.docsUrl("jsx-function-call-newline")
         },
         fixable: "whitespace",
         messages,
@@ -15442,7 +15433,7 @@ var require_jsx_sort_props = __commonJS({
         let comment = [];
         try {
           comment = sourceCode.getCommentsAfter(attribute);
-        } catch (e) {
+        } catch {
         }
         const lastAttr = attributes[i - 1];
         const attrIsSpread = attribute.type === "JSXSpreadAttribute";
@@ -15583,7 +15574,6 @@ var require_jsx_sort_props = __commonJS({
         type: "layout",
         docs: {
           description: "Enforce props alphabetical sorting",
-          recommended: "stylistic",
           url: utils.docsUrl("jsx-sort-props")
         },
         fixable: "code",
@@ -16431,54 +16421,31 @@ var require_utils3 = __commonJS({
   }
 });
-// node_modules/@stylistic/eslint-plugin-ts/dist/configs.js
-var require_configs3 = __commonJS({
-  "node_modules/@stylistic/eslint-plugin-ts/dist/configs.js"(exports2) {
+// node_modules/@stylistic/eslint-plugin-ts/dist/block-spacing.js
+var require_block_spacing2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/block-spacing.js"(exports2, module2) {
     "use strict";
     var utils$1 = require("@typescript-eslint/utils");
     var astUtils = require("@typescript-eslint/utils/ast-utils");
     var utils = require_utils3();
-    function createAllConfigs(plugin2, name, flat, filter) {
-      const rules2 = Object.fromEntries(
-        Object.entries(plugin2.rules).filter(
-          ([key, rule]) => (
-            // Only include fixable rules
-            rule.meta.fixable && !rule.meta.deprecated && key === rule.meta.docs.url.split("/").pop() && !filter
-          )
-        ).map(([key]) => [`${name}/${key}`, 2])
-      );
-      if (flat) {
-        return {
-          plugins: {
-            [name]: plugin2
-          },
-          rules: rules2
-        };
-      } else {
-        return {
-          plugins: [name],
-          rules: rules2
-        };
-      }
-    }
-    var baseRule$h = utils.getESLintCoreRule("block-spacing");
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("block-spacing");
     var blockSpacing = utils.createRule({
       name: "block-spacing",
       meta: {
         type: "layout",
         docs: {
-          description: "Disallow or enforce spaces inside of blocks after opening block and before closing block",
-          extendsBaseRule: true
+          description: "Disallow or enforce spaces inside of blocks after opening block and before closing block"
         },
         fixable: "whitespace",
-        hasSuggestions: baseRule$h.meta.hasSuggestions,
-        schema: baseRule$h.meta.schema,
-        messages: baseRule$h.meta.messages
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: baseRule.meta.schema,
+        messages: baseRule.meta.messages
       },
       defaultOptions: ["always"],
       create(context, [whenToApplyOption]) {
         const sourceCode = context.sourceCode;
-        const baseRules = baseRule$h.create(context);
+        const baseRules = baseRule.create(context);
         const always = whenToApplyOption !== "never";
         const messageId = always ? "missing" : "extra";
         function getOpenBrace(node) {
@@ -16562,26 +16529,37 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$g = utils.getESLintCoreRule("brace-style");
+    module2.exports = blockSpacing;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/brace-style.js
+var require_brace_style2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/brace-style.js"(exports2, module2) {
+    "use strict";
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("brace-style");
     var braceStyle = utils.createRule({
       name: "brace-style",
       meta: {
         type: "layout",
         docs: {
-          description: "Enforce consistent brace style for blocks",
-          extendsBaseRule: true
+          description: "Enforce consistent brace style for blocks"
         },
-        messages: baseRule$g.meta.messages,
-        fixable: baseRule$g.meta.fixable,
-        hasSuggestions: baseRule$g.meta.hasSuggestions,
-        schema: baseRule$g.meta.schema
+        messages: baseRule.meta.messages,
+        fixable: baseRule.meta.fixable,
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: baseRule.meta.schema
       },
       defaultOptions: ["1tbs"],
       create(context) {
         const [style, { allowSingleLine } = { allowSingleLine: false }] = context.options;
         const isAllmanStyle = style === "allman";
         const sourceCode = context.sourceCode;
-        const rules2 = baseRule$g.create(context);
+        const rules = baseRule.create(context);
         function validateCurlyPair(openingCurlyToken, closingCurlyToken) {
           if (allowSingleLine && astUtils.isTokenOnSameLine(openingCurlyToken, closingCurlyToken)) {
             return;
@@ -16631,7 +16609,7 @@ var require_configs3 = __commonJS({
           }
         }
         return {
-          ...rules2,
+          ...rules,
           "TSInterfaceBody, TSModuleBlock": function(node) {
             const openingCurly = sourceCode.getFirstToken(node);
             const closingCurly = sourceCode.getLastToken(node);
@@ -16639,15 +16617,28 @@ var require_configs3 = __commonJS({
           },
           TSEnumDeclaration(node) {
             const closingCurly = sourceCode.getLastToken(node);
+            const members = node.body?.members || node.members;
             const openingCurly = sourceCode.getTokenBefore(
-              node.members.length ? node.members[0] : closingCurly
+              members.length ? members[0] : closingCurly
             );
             validateCurlyPair(openingCurly, closingCurly);
           }
         };
       }
     });
-    var baseRule$f = utils.getESLintCoreRule("comma-dangle");
+    module2.exports = braceStyle;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/comma-dangle.js
+var require_comma_dangle2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/comma-dangle.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("comma-dangle");
     var OPTION_VALUE_SCHEME = [
       "always-multiline",
       "always",
@@ -16674,8 +16665,7 @@ var require_configs3 = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Require or disallow trailing commas",
-          extendsBaseRule: true
+          description: "Require or disallow trailing commas"
         },
         schema: {
           $defs: {
@@ -16715,12 +16705,12 @@ var require_configs3 = __commonJS({
           additionalItems: false
         },
         fixable: "code",
-        hasSuggestions: baseRule$f.meta.hasSuggestions,
-        messages: baseRule$f.meta.messages
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages
       },
       defaultOptions: ["never"],
       create(context, [options]) {
-        const rules2 = baseRule$f.create(context);
+        const rules = baseRule.create(context);
         const sourceCode = context.sourceCode;
         const normalizedOptions = normalizeOptions(options);
         const isTSX = context.parserOptions?.ecmaFeatures?.jsx && context.filename?.endsWith(".tsx");
@@ -16739,7 +16729,7 @@ var require_configs3 = __commonJS({
         function getLastItem(node) {
           switch (node.type) {
             case utils$1.AST_NODE_TYPES.TSEnumDeclaration:
-              return last(node.members);
+              return last(node.body?.members || node.members);
             case utils$1.AST_NODE_TYPES.TSTypeParameterDeclaration:
               return last(node.params);
             case utils$1.AST_NODE_TYPES.TSTupleType:
@@ -16797,20 +16787,31 @@ var require_configs3 = __commonJS({
             forbidComma(node);
         }
         return {
-          ...rules2,
+          ...rules,
           TSEnumDeclaration: predicate[normalizedOptions.enums],
           TSTypeParameterDeclaration: predicate[normalizedOptions.generics],
           TSTupleType: predicate[normalizedOptions.tuples]
         };
       }
     });
+    module2.exports = commaDangle;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/comma-spacing.js
+var require_comma_spacing2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/comma-spacing.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils = require_utils3();
+    require_dist();
     var commaSpacing = utils.createRule({
       name: "comma-spacing",
       meta: {
         type: "layout",
         docs: {
-          description: "Enforce consistent spacing before and after commas",
-          extendsBaseRule: true
+          description: "Enforce consistent spacing before and after commas"
         },
         fixable: "whitespace",
         schema: [
@@ -16923,13 +16924,24 @@ var require_configs3 = __commonJS({
         };
       }
     });
+    module2.exports = commaSpacing;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/function-call-spacing.js
+var require_function_call_spacing2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/function-call-spacing.js"(exports2, module2) {
+    "use strict";
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
     var functionCallSpacing = utils.createRule({
       name: "function-call-spacing",
       meta: {
         type: "layout",
         docs: {
-          description: "Require or disallow spacing between function identifiers and their invocations",
-          extendsBaseRule: true
+          description: "Require or disallow spacing between function identifiers and their invocations"
         },
         fixable: "whitespace",
         schema: {
@@ -16974,7 +16986,7 @@ var require_configs3 = __commonJS({
         }
       },
       defaultOptions: ["never", {}],
-      create(context, [option, config2]) {
+      create(context, [option, config]) {
         const sourceCode = context.sourceCode;
         const text = sourceCode.getText();
         function checkSpacing(node) {
@@ -17033,7 +17045,7 @@ var require_configs3 = __commonJS({
                   return fixer.insertTextBefore(openingParenToken, " ");
                 }
               });
-            } else if (!config2.allowNewlines && hasNewline) {
+            } else if (!config.allowNewlines && hasNewline) {
               context.report({
                 node,
                 loc: lastCalleeToken.loc.start,
@@ -17054,7 +17066,18 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$e = utils.getESLintCoreRule("indent");
+    module2.exports = functionCallSpacing;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/indent.js
+var require_indent2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/indent.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("indent");
     var KNOWN_NODES = /* @__PURE__ */ new Set([
       // Class properties aren't yet supported by eslint...
       utils$1.AST_NODE_TYPES.PropertyDefinition,
@@ -17126,14 +17149,13 @@ var require_configs3 = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Enforce consistent indentation",
+          description: "Enforce consistent indentation"
           // too opinionated to be recommended
-          extendsBaseRule: true
         },
         fixable: "whitespace",
-        hasSuggestions: baseRule$e.meta.hasSuggestions,
-        schema: baseRule$e.meta.schema,
-        messages: baseRule$e.meta.messages
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: baseRule.meta.schema,
+        messages: baseRule.meta.messages
       },
       defaultOptions: [
         // typescript docs and playground use 4 space indent
@@ -17154,7 +17176,7 @@ var require_configs3 = __commonJS({
             value: optionsWithDefaults
           }
         });
-        const rules2 = baseRule$e.create(contextWithDefaults);
+        const rules = baseRule.create(contextWithDefaults);
         function TSPropertySignatureToProperty(node, type = utils$1.AST_NODE_TYPES.Property) {
           const base = {
             // indent doesn't actually use these
@@ -17173,8 +17195,8 @@ var require_configs3 = __commonJS({
           };
           if (type === utils$1.AST_NODE_TYPES.Property) {
             return {
-              type,
-              ...base
+              ...base,
+              type
             };
           }
           return {
@@ -17192,21 +17214,21 @@ var require_configs3 = __commonJS({
           };
         }
         return {
-          ...rules2,
+          ...rules,
           // overwrite the base rule here so we can use our KNOWN_NODES list instead
           "*:exit": function(node) {
             if (!KNOWN_NODES.has(node.type))
-              rules2["*:exit"](node);
+              rules["*:exit"](node);
           },
           PropertyDefinition(node) {
             if (node.parent.type !== utils$1.AST_NODE_TYPES.ClassBody || !node.decorators?.length || node.loc.start.line === node.loc.end.line)
-              return rules2.PropertyDefinition(node);
+              return rules.PropertyDefinition(node);
             let startDecorator = node.decorators[0];
             let endDecorator = startDecorator;
             for (let i = 1; i <= node.decorators.length; i++) {
               const decorator = node.decorators[i];
               if (i === node.decorators.length || startDecorator.loc.start.line !== decorator.loc.start.line) {
-                rules2.PropertyDefinition({
+                rules.PropertyDefinition({
                   type: utils$1.AST_NODE_TYPES.PropertyDefinition,
                   key: node.key,
                   parent: node.parent,
@@ -17222,7 +17244,7 @@ var require_configs3 = __commonJS({
                 endDecorator = decorator;
               }
             }
-            return rules2.PropertyDefinition({
+            return rules.PropertyDefinition({
               ...node,
               range: [endDecorator.range[1] + 1, node.range[1]],
               loc: {
@@ -17234,10 +17256,10 @@ var require_configs3 = __commonJS({
           VariableDeclaration(node) {
             if (node.declarations.length === 0)
               return;
-            return rules2.VariableDeclaration(node);
+            return rules.VariableDeclaration(node);
           },
           TSAsExpression(node) {
-            return rules2["BinaryExpression, LogicalExpression"]({
+            return rules["BinaryExpression, LogicalExpression"]({
               type: utils$1.AST_NODE_TYPES.BinaryExpression,
               operator: "as",
               left: node.expression,
@@ -17250,7 +17272,7 @@ var require_configs3 = __commonJS({
             });
           },
           TSConditionalType(node) {
-            return rules2.ConditionalExpression({
+            return rules.ConditionalExpression({
               type: utils$1.AST_NODE_TYPES.ConditionalExpression,
               test: {
                 parent: node,
@@ -17274,9 +17296,10 @@ var require_configs3 = __commonJS({
             });
           },
           "TSEnumDeclaration, TSTypeLiteral": function(node) {
-            return rules2["ObjectExpression, ObjectPattern"]({
+            const members = "body" in node ? node.body?.members || node.members : node.members;
+            return rules["ObjectExpression, ObjectPattern"]({
               type: utils$1.AST_NODE_TYPES.ObjectExpression,
-              properties: node.members.map(
+              properties: members.map(
                 (member) => TSPropertySignatureToProperty(member)
               ),
               // location data
@@ -17287,7 +17310,7 @@ var require_configs3 = __commonJS({
           },
           TSImportEqualsDeclaration(node) {
             const { id, moduleReference } = node;
-            return rules2.VariableDeclaration({
+            return rules.VariableDeclaration({
               type: utils$1.AST_NODE_TYPES.VariableDeclaration,
               kind: "const",
               declarations: [
@@ -17331,7 +17354,7 @@ var require_configs3 = __commonJS({
             });
           },
           TSIndexedAccessType(node) {
-            return rules2["MemberExpression, JSXMemberExpression, MetaProperty"]({
+            return rules["MemberExpression, JSXMemberExpression, MetaProperty"]({
               type: utils$1.AST_NODE_TYPES.MemberExpression,
               object: node.objectType,
               property: node.indexType,
@@ -17344,7 +17367,7 @@ var require_configs3 = __commonJS({
             });
           },
           TSInterfaceBody(node) {
-            return rules2["BlockStatement, ClassBody"]({
+            return rules["BlockStatement, ClassBody"]({
               type: utils$1.AST_NODE_TYPES.ClassBody,
               body: node.body.map(
                 (p) => TSPropertySignatureToProperty(
@@ -17359,7 +17382,7 @@ var require_configs3 = __commonJS({
             });
           },
           "TSInterfaceDeclaration[extends.length > 0]": function(node) {
-            return rules2["ClassDeclaration[superClass], ClassExpression[superClass]"](
+            return rules["ClassDeclaration[superClass], ClassExpression[superClass]"](
               {
                 type: utils$1.AST_NODE_TYPES.ClassDeclaration,
                 body: node.body,
@@ -17383,15 +17406,15 @@ var require_configs3 = __commonJS({
           TSMappedType(node) {
             const sourceCode = context.sourceCode;
             const squareBracketStart = sourceCode.getTokenBefore(
-              node.typeParameter
+              node.constraint || node.typeParameter
             );
-            return rules2["ObjectExpression, ObjectPattern"]({
+            return rules["ObjectExpression, ObjectPattern"]({
               type: utils$1.AST_NODE_TYPES.ObjectExpression,
               properties: [
                 {
                   parent: node,
                   type: utils$1.AST_NODE_TYPES.Property,
-                  key: node.typeParameter,
+                  key: node.key || node.typeParameter,
                   value: node.typeAnnotation,
                   // location data
                   range: [
@@ -17416,7 +17439,7 @@ var require_configs3 = __commonJS({
             });
           },
           TSModuleBlock(node) {
-            return rules2["BlockStatement, ClassBody"]({
+            return rules["BlockStatement, ClassBody"]({
               type: utils$1.AST_NODE_TYPES.BlockStatement,
               body: node.body,
               // location data
@@ -17426,7 +17449,7 @@ var require_configs3 = __commonJS({
             });
           },
           TSQualifiedName(node) {
-            return rules2["MemberExpression, JSXMemberExpression, MetaProperty"]({
+            return rules["MemberExpression, JSXMemberExpression, MetaProperty"]({
               type: utils$1.AST_NODE_TYPES.MemberExpression,
               object: node.left,
               property: node.right,
@@ -17439,7 +17462,7 @@ var require_configs3 = __commonJS({
             });
           },
           TSTupleType(node) {
-            return rules2["ArrayExpression, ArrayPattern"]({
+            return rules["ArrayExpression, ArrayPattern"]({
               type: utils$1.AST_NODE_TYPES.ArrayExpression,
               elements: node.elementTypes,
               // location data
@@ -17452,7 +17475,7 @@ var require_configs3 = __commonJS({
             if (!node.params.length)
               return;
             const [name, ...attributes] = node.params;
-            return rules2.JSXOpeningElement({
+            return rules.JSXOpeningElement({
               type: utils$1.AST_NODE_TYPES.JSXOpeningElement,
               selfClosing: false,
               name,
@@ -17469,7 +17492,7 @@ var require_configs3 = __commonJS({
             if (!node.params.length)
               return;
             const [name, ...attributes] = node.params;
-            return rules2.JSXOpeningElement({
+            return rules.JSXOpeningElement({
               type: utils$1.AST_NODE_TYPES.JSXOpeningElement,
               selfClosing: false,
               name,
@@ -17485,8 +17508,20 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$d = utils.getESLintCoreRule("key-spacing");
-    var baseSchema$1 = Array.isArray(baseRule$d.meta.schema) ? baseRule$d.meta.schema[0] : baseRule$d.meta.schema;
+    module2.exports = indent;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/key-spacing.js
+var require_key_spacing2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/key-spacing.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("key-spacing");
+    var baseSchema = Array.isArray(baseRule.meta.schema) ? baseRule.meta.schema[0] : baseRule.meta.schema;
     function at(arr, position) {
       if (position < 0)
         return arr[arr.length + position];
@@ -17497,19 +17532,18 @@ var require_configs3 = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Enforce consistent spacing between property names and type annotations in types and interfaces",
-          extendsBaseRule: true
+          description: "Enforce consistent spacing between property names and type annotations in types and interfaces"
         },
         fixable: "whitespace",
-        hasSuggestions: baseRule$d.meta.hasSuggestions,
-        schema: [baseSchema$1],
-        messages: baseRule$d.meta.messages
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: [baseSchema],
+        messages: baseRule.meta.messages
       },
       defaultOptions: [{}],
       create(context, [_options]) {
         const options = _options || {};
         const sourceCode = context.sourceCode;
-        const baseRules = baseRule$d.create(context);
+        const baseRules = baseRule.create(context);
         function adjustedColumn(position) {
           const line = position.line - 1;
           return utils.getStringLength(
@@ -17722,9 +17756,20 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$c = utils.getESLintCoreRule("keyword-spacing");
-    var baseSchema = Array.isArray(baseRule$c.meta.schema) ? baseRule$c.meta.schema[0] : baseRule$c.meta.schema;
-    var schema$1 = utils.deepMerge(
+    module2.exports = keySpacing;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/keyword-spacing.js
+var require_keyword_spacing2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/keyword-spacing.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("keyword-spacing");
+    var baseSchema = Array.isArray(baseRule.meta.schema) ? baseRule.meta.schema[0] : baseRule.meta.schema;
+    var schema = utils.deepMerge(
       baseSchema,
       {
         properties: {
@@ -17741,19 +17786,18 @@ var require_configs3 = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Enforce consistent spacing before and after keywords",
-          extendsBaseRule: true
+          description: "Enforce consistent spacing before and after keywords"
         },
         fixable: "whitespace",
-        hasSuggestions: baseRule$c.meta.hasSuggestions,
-        schema: [schema$1],
-        messages: baseRule$c.meta.messages
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: [schema],
+        messages: baseRule.meta.messages
       },
       defaultOptions: [{}],
       create(context, [options]) {
         const { after, overrides } = options ?? {};
         const sourceCode = context.sourceCode;
-        const baseRules = baseRule$c.create(context);
+        const baseRules = baseRule.create(context);
         return {
           ...baseRules,
           TSAsExpression(node) {
@@ -17803,7 +17847,19 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$b = utils.getESLintCoreRule("lines-around-comment");
+    module2.exports = keywordSpacing;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/lines-around-comment.js
+var require_lines_around_comment2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/lines-around-comment.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("lines-around-comment");
     var COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
     function getEmptyLineNums(lines) {
       const emptyLines = lines.map((line, i) => ({
@@ -17826,8 +17882,7 @@ var require_configs3 = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Require empty lines around comments",
-          extendsBaseRule: true
+          description: "Require empty lines around comments"
         },
         schema: [
           {
@@ -17912,9 +17967,9 @@ var require_configs3 = __commonJS({
             additionalProperties: false
           }
         ],
-        fixable: baseRule$b.meta.fixable,
-        hasSuggestions: baseRule$b.meta.hasSuggestions,
-        messages: baseRule$b.meta.messages
+        fixable: baseRule.meta.fixable,
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages
       },
       defaultOptions: [
         {
@@ -17982,10 +18037,10 @@ var require_configs3 = __commonJS({
           return isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSTypeLiteral);
         }
         function isCommentAtEnumStart(token) {
-          return isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSEnumDeclaration);
+          return isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSEnumBody) || isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSEnumDeclaration);
         }
         function isCommentAtEnumEnd(token) {
-          return isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSEnumDeclaration);
+          return isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSEnumBody) || isCommentAtParentEnd(token, utils$1.AST_NODE_TYPES.TSEnumDeclaration);
         }
         function isCommentAtModuleStart(token) {
           return isCommentAtParentStart(token, utils$1.AST_NODE_TYPES.TSModuleBlock);
@@ -18065,10 +18120,10 @@ var require_configs3 = __commonJS({
             }
           }
         );
-        const rules2 = baseRule$b.create(proxiedContext);
+        const rules = baseRule.create(proxiedContext);
         return {
           Program(node) {
-            rules2.Program(node);
+            rules.Program(node);
             comments.forEach((token) => {
               if (token.type === utils$1.AST_TOKEN_TYPES.Line) {
                 if (options.beforeLineComment || options.afterLineComment) {
@@ -18090,10 +18145,21 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$a = utils.getESLintCoreRule("lines-between-class-members");
+    module2.exports = linesAroundComment;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/lines-between-class-members.js
+var require_lines_between_class_members2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/lines-between-class-members.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("lines-between-class-members");
     var schema = Object.values(
       utils.deepMerge(
-        { ...baseRule$a.meta.schema },
+        { ...baseRule.meta.schema },
         {
           1: {
             properties: {
@@ -18111,13 +18177,12 @@ var require_configs3 = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Require or disallow an empty line between class members",
-          extendsBaseRule: true
+          description: "Require or disallow an empty line between class members"
         },
         fixable: "whitespace",
-        hasSuggestions: baseRule$a.meta.hasSuggestions,
+        hasSuggestions: baseRule.meta.hasSuggestions,
         schema,
-        messages: baseRule$a.meta.messages
+        messages: baseRule.meta.messages
       },
       defaultOptions: [
         "always",
@@ -18127,7 +18192,7 @@ var require_configs3 = __commonJS({
         }
       ],
       create(context, [firstOption, secondOption]) {
-        const rules2 = baseRule$a.create(context);
+        const rules = baseRule.create(context);
         const exceptAfterOverload = secondOption?.exceptAfterOverload && firstOption === "always";
         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;
@@ -18135,11 +18200,22 @@ var require_configs3 = __commonJS({
         return {
           ClassBody(node) {
             const body = exceptAfterOverload ? node.body.filter((node2) => !isOverload(node2)) : node.body;
-            rules2.ClassBody({ ...node, body });
+            rules.ClassBody({ ...node, body });
           }
         };
       }
     });
+    module2.exports = linesBetweenClassMembers;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/member-delimiter-style.js
+var require_member_delimiter_style = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/member-delimiter-style.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
     function isLastTokenEndOfLine(token, line) {
       const positionInLine = token.loc.start.column;
       return positionInLine === line.length - 1;
@@ -18364,26 +18440,37 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$9 = utils.getESLintCoreRule("no-extra-parens");
+    module2.exports = memberDelimiterStyle;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/no-extra-parens.js
+var require_no_extra_parens2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/no-extra-parens.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("no-extra-parens");
     var noExtraParens = utils.createRule({
       name: "no-extra-parens",
       meta: {
         type: "layout",
         docs: {
-          description: "Disallow unnecessary parentheses",
-          extendsBaseRule: true
+          description: "Disallow unnecessary parentheses"
         },
         fixable: "code",
-        hasSuggestions: baseRule$9.meta.hasSuggestions,
-        schema: baseRule$9.meta.schema,
-        messages: baseRule$9.meta.messages
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: baseRule.meta.schema,
+        messages: baseRule.meta.messages
       },
       defaultOptions: ["all"],
       create(context) {
         const sourceCode = context.sourceCode;
-        const rules2 = baseRule$9.create(context);
+        const rules = baseRule.create(context);
         function binaryExp(node) {
-          const rule = rules2.BinaryExpression;
+          const rule = rules.BinaryExpression;
           const isLeftTypeAssertion = astUtils.isTypeAssertion(node.left);
           const isRightTypeAssertion = astUtils.isTypeAssertion(node.right);
           if (isLeftTypeAssertion && isRightTypeAssertion)
@@ -18409,7 +18496,7 @@ var require_configs3 = __commonJS({
           return rule(node);
         }
         function callExp(node) {
-          const rule = rules2.CallExpression;
+          const rule = rules.CallExpression;
           if (astUtils.isTypeAssertion(node.callee)) {
             return rule({
               ...node,
@@ -18433,7 +18520,7 @@ var require_configs3 = __commonJS({
           return rule(node);
         }
         function unaryUpdateExpression(node) {
-          const rule = rules2.UnaryExpression;
+          const rule = rules.UnaryExpression;
           if (astUtils.isTypeAssertion(node.argument)) {
             return rule({
               ...node,
@@ -18449,7 +18536,7 @@ var require_configs3 = __commonJS({
           ArrayExpression(node) {
             node.elements.forEach((element, index2) => {
               if (astUtils.isTypeAssertion(element)) {
-                return rules2.ArrayExpression({
+                return rules.ArrayExpression({
                   ...node,
                   elements: [
                     ...node.elements.slice(0, index2),
@@ -18465,12 +18552,12 @@ var require_configs3 = __commonJS({
           },
           ArrowFunctionExpression(node) {
             if (!astUtils.isTypeAssertion(node.body))
-              return rules2.ArrowFunctionExpression(node);
+              return rules.ArrowFunctionExpression(node);
           },
           // AssignmentExpression
           AwaitExpression(node) {
             if (astUtils.isTypeAssertion(node.argument)) {
-              return rules2.AwaitExpression({
+              return rules.AwaitExpression({
                 ...node,
                 argument: {
                   ...node.argument,
@@ -18478,13 +18565,13 @@ var require_configs3 = __commonJS({
                 }
               });
             }
-            return rules2.AwaitExpression(node);
+            return rules.AwaitExpression(node);
           },
           "BinaryExpression": binaryExp,
           "CallExpression": callExp,
           ClassDeclaration(node) {
             if (node.superClass?.type === utils$1.AST_NODE_TYPES.TSAsExpression) {
-              return rules2.ClassDeclaration({
+              return rules.ClassDeclaration({
                 ...node,
                 superClass: {
                   ...node.superClass,
@@ -18492,11 +18579,11 @@ var require_configs3 = __commonJS({
                 }
               });
             }
-            return rules2.ClassDeclaration(node);
+            return rules.ClassDeclaration(node);
           },
           ClassExpression(node) {
             if (node.superClass?.type === utils$1.AST_NODE_TYPES.TSAsExpression) {
-              return rules2.ClassExpression({
+              return rules.ClassExpression({
                 ...node,
                 superClass: {
                   ...node.superClass,
@@ -18504,11 +18591,11 @@ var require_configs3 = __commonJS({
                 }
               });
             }
-            return rules2.ClassExpression(node);
+            return rules.ClassExpression(node);
           },
           ConditionalExpression(node) {
             if (astUtils.isTypeAssertion(node.test)) {
-              return rules2.ConditionalExpression({
+              return rules.ConditionalExpression({
                 ...node,
                 test: {
                   ...node.test,
@@ -18517,7 +18604,7 @@ var require_configs3 = __commonJS({
               });
             }
             if (astUtils.isTypeAssertion(node.consequent)) {
-              return rules2.ConditionalExpression({
+              return rules.ConditionalExpression({
                 ...node,
                 consequent: {
                   ...node.consequent,
@@ -18526,7 +18613,7 @@ var require_configs3 = __commonJS({
               });
             }
             if (astUtils.isTypeAssertion(node.alternate)) {
-              return rules2.ConditionalExpression({
+              return rules.ConditionalExpression({
                 ...node,
                 alternate: {
                   ...node.alternate,
@@ -18534,40 +18621,40 @@ var require_configs3 = __commonJS({
                 }
               });
             }
-            return rules2.ConditionalExpression(node);
+            return rules.ConditionalExpression(node);
           },
           // DoWhileStatement
           // ForIn and ForOf are guarded by eslint version
           ForStatement(node) {
             if (node.init && astUtils.isTypeAssertion(node.init)) {
-              return rules2.ForStatement({
+              return rules.ForStatement({
                 ...node,
                 init: null
               });
             }
             if (node.test && astUtils.isTypeAssertion(node.test)) {
-              return rules2.ForStatement({
+              return rules.ForStatement({
                 ...node,
                 test: null
               });
             }
             if (node.update && astUtils.isTypeAssertion(node.update)) {
-              return rules2.ForStatement({
+              return rules.ForStatement({
                 ...node,
                 update: null
               });
             }
-            return rules2.ForStatement(node);
+            return rules.ForStatement(node);
           },
           "ForStatement > *.init:exit": function(node) {
             if (!astUtils.isTypeAssertion(node))
-              return rules2["ForStatement > *.init:exit"](node);
+              return rules["ForStatement > *.init:exit"](node);
           },
           // IfStatement
           "LogicalExpression": binaryExp,
           MemberExpression(node) {
             if (astUtils.isTypeAssertion(node.object)) {
-              return rules2.MemberExpression({
+              return rules.MemberExpression({
                 ...node,
                 object: {
                   ...node.object,
@@ -18576,7 +18663,7 @@ var require_configs3 = __commonJS({
               });
             }
             if (astUtils.isTypeAssertion(node.property)) {
-              return rules2.MemberExpression({
+              return rules.MemberExpression({
                 ...node,
                 property: {
                   ...node.property,
@@ -18584,7 +18671,7 @@ var require_configs3 = __commonJS({
                 }
               });
             }
-            return rules2.MemberExpression(node);
+            return rules.MemberExpression(node);
           },
           "NewExpression": callExp,
           // ObjectExpression
@@ -18592,23 +18679,23 @@ var require_configs3 = __commonJS({
           // SequenceExpression
           SpreadElement(node) {
             if (!astUtils.isTypeAssertion(node.argument))
-              return rules2.SpreadElement(node);
+              return rules.SpreadElement(node);
           },
           SwitchCase(node) {
             if (node.test && !astUtils.isTypeAssertion(node.test))
-              return rules2.SwitchCase(node);
+              return rules.SwitchCase(node);
           },
           // SwitchStatement
           ThrowStatement(node) {
             if (node.argument && !astUtils.isTypeAssertion(node.argument))
-              return rules2.ThrowStatement(node);
+              return rules.ThrowStatement(node);
           },
           "UnaryExpression": unaryUpdateExpression,
           "UpdateExpression": unaryUpdateExpression,
           // VariableDeclarator
           VariableDeclarator(node) {
             if (astUtils.isTypeAssertion(node.init)) {
-              return rules2.VariableDeclarator({
+              return rules.VariableDeclarator({
                 ...node,
                 type: utils$1.AST_NODE_TYPES.VariableDeclarator,
                 init: {
@@ -18617,23 +18704,23 @@ var require_configs3 = __commonJS({
                 }
               });
             }
-            return rules2.VariableDeclarator(node);
+            return rules.VariableDeclarator(node);
           },
           // WhileStatement
           // WithStatement - i'm not going to even bother implementing this terrible and never used feature
           YieldExpression(node) {
             if (node.argument && !astUtils.isTypeAssertion(node.argument))
-              return rules2.YieldExpression(node);
+              return rules.YieldExpression(node);
           },
           ForInStatement(node) {
             if (astUtils.isTypeAssertion(node.right)) {
               return;
             }
-            return rules2.ForInStatement(node);
+            return rules.ForInStatement(node);
           },
           ForOfStatement(node) {
             if (astUtils.isTypeAssertion(node.right)) {
-              return rules2.ForOfStatement({
+              return rules.ForOfStatement({
                 ...node,
                 type: utils$1.AST_NODE_TYPES.ForOfStatement,
                 right: {
@@ -18642,52 +18729,72 @@ var require_configs3 = __commonJS({
                 }
               });
             }
-            return rules2.ForOfStatement(node);
+            return rules.ForOfStatement(node);
           },
           TSStringKeyword(node) {
-            return rules2.TSStringKeyword({
+            return rules.TSStringKeyword({
               ...node,
               type: utils$1.AST_NODE_TYPES.FunctionExpression
             });
           }
         };
-        return Object.assign({}, rules2, overrides);
+        return Object.assign({}, rules, overrides);
       }
     });
-    var baseRule$8 = utils.getESLintCoreRule("no-extra-semi");
+    module2.exports = noExtraParens;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/no-extra-semi.js
+var require_no_extra_semi2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/no-extra-semi.js"(exports2, module2) {
+    "use strict";
+    require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("no-extra-semi");
     var noExtraSemi = utils.createRule({
       name: "no-extra-semi",
       meta: {
         type: "layout",
         docs: {
-          description: "Disallow unnecessary semicolons",
-          extendsBaseRule: true
+          description: "Disallow unnecessary semicolons"
         },
         fixable: "code",
-        hasSuggestions: baseRule$8.meta.hasSuggestions,
-        schema: baseRule$8.meta.schema,
-        messages: baseRule$8.meta.messages
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: baseRule.meta.schema,
+        messages: baseRule.meta.messages
       },
       defaultOptions: [],
       create(context) {
-        const rules2 = baseRule$8.create(context);
+        const rules = baseRule.create(context);
         return {
-          ...rules2,
+          ...rules,
           "TSAbstractMethodDefinition, TSAbstractPropertyDefinition": function(node) {
-            rules2["MethodDefinition, PropertyDefinition, StaticBlock"]?.(node);
+            rules["MethodDefinition, PropertyDefinition, StaticBlock"]?.(node);
           }
         };
       }
     });
-    var baseRule$7 = utils.getESLintCoreRule("object-curly-newline");
+    module2.exports = noExtraSemi;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/object-curly-newline.js
+var require_object_curly_newline2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/object-curly-newline.js"(exports2, module2) {
+    "use strict";
+    require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("object-curly-newline");
     var defaultOptionValue = { multiline: false, minProperties: Number.POSITIVE_INFINITY, consistent: true };
     var objectCurlyNewline = utils.createRule({
       name: "object-curly-newline",
       meta: {
-        ...baseRule$7.meta,
+        ...baseRule.meta,
         docs: {
-          description: "Enforce consistent line breaks after opening and before closing braces",
-          extendsBaseRule: true
+          description: "Enforce consistent line breaks after opening and before closing braces"
         }
       },
       defaultOptions: [
@@ -18701,19 +18808,30 @@ var require_configs3 = __commonJS({
         }
       ],
       create(context) {
-        const rules2 = baseRule$7.create(context);
-        return rules2;
+        const rules = baseRule.create(context);
+        return rules;
       }
     });
-    var baseRule$6 = utils.getESLintCoreRule("object-curly-spacing");
+    module2.exports = objectCurlyNewline;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/object-curly-spacing.js
+var require_object_curly_spacing2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/object-curly-spacing.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("object-curly-spacing");
     var objectCurlySpacing = utils.createRule({
       name: "object-curly-spacing",
       //
       meta: {
-        ...baseRule$6.meta,
+        ...baseRule.meta,
         docs: {
-          description: "Enforce consistent spacing inside braces",
-          extendsBaseRule: true
+          description: "Enforce consistent spacing inside braces"
         }
       },
       defaultOptions: ["never"],
@@ -18817,9 +18935,9 @@ var require_configs3 = __commonJS({
           const lastProperty = node.members[node.members.length - 1];
           return sourceCode.getTokenAfter(lastProperty, astUtils.isClosingBraceToken);
         }
-        const rules2 = baseRule$6.create(context);
+        const rules = baseRule.create(context);
         return {
-          ...rules2,
+          ...rules,
           TSMappedType(node) {
             const first = sourceCode.getFirstToken(node);
             const last = sourceCode.getLastToken(node);
@@ -18847,14 +18965,24 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$5 = utils.getESLintCoreRule("object-property-newline");
+    module2.exports = objectCurlySpacing;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/object-property-newline.js
+var require_object_property_newline2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/object-property-newline.js"(exports2, module2) {
+    "use strict";
+    require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("object-property-newline");
     var objectPropertyNewline = utils.createRule({
       name: "object-property-newline",
       meta: {
-        ...baseRule$5.meta,
+        ...baseRule.meta,
         docs: {
-          description: "Enforce placing object properties on separate lines",
-          extendsBaseRule: true
+          description: "Enforce placing object properties on separate lines"
         }
       },
       defaultOptions: [
@@ -18864,18 +18992,18 @@ var require_configs3 = __commonJS({
         }
       ],
       create(context) {
-        const rules2 = baseRule$5.create(context);
+        const rules = baseRule.create(context);
         return {
-          ...rules2,
+          ...rules,
           TSTypeLiteral(node) {
-            return rules2.ObjectExpression({
+            return rules.ObjectExpression({
               ...node,
               // @ts-expect-error only used to get token and loc
               properties: node.members
             });
           },
           TSInterfaceBody(node) {
-            return rules2.ObjectExpression({
+            return rules.ObjectExpression({
               ...node,
               // @ts-expect-error only used to get token and loc
               properties: node.body
@@ -18884,6 +19012,18 @@ var require_configs3 = __commonJS({
         };
       }
     });
+    module2.exports = objectPropertyNewline;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/padding-line-between-statements.js
+var require_padding_line_between_statements2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/padding-line-between-statements.js"(exports2, module2) {
+    "use strict";
+    var utils = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils$1 = require_utils3();
+    require_dist();
     var CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u;
     var CJS_IMPORT = /^require\(/u;
     var LT = `[${Array.from(
@@ -18922,16 +19062,16 @@ var require_configs3 = __commonJS({
       };
     }
     function skipChainExpression(node) {
-      return node && node.type === utils$1.AST_NODE_TYPES.ChainExpression ? node.expression : node;
+      return node && node.type === utils.AST_NODE_TYPES.ChainExpression ? node.expression : node;
     }
     function isIIFEStatement(node) {
-      if (node.type === utils$1.AST_NODE_TYPES.ExpressionStatement) {
+      if (node.type === utils.AST_NODE_TYPES.ExpressionStatement) {
         let expression = skipChainExpression(node.expression);
-        if (expression.type === utils$1.AST_NODE_TYPES.UnaryExpression)
+        if (expression.type === utils.AST_NODE_TYPES.UnaryExpression)
           expression = skipChainExpression(expression.argument);
-        if (expression.type === utils$1.AST_NODE_TYPES.CallExpression) {
+        if (expression.type === utils.AST_NODE_TYPES.CallExpression) {
           let node2 = expression.callee;
-          while (node2.type === utils$1.AST_NODE_TYPES.SequenceExpression)
+          while (node2.type === utils.AST_NODE_TYPES.SequenceExpression)
             node2 = node2.expressions[node2.expressions.length - 1];
           return astUtils.isFunction(node2);
         }
@@ -18939,13 +19079,13 @@ var require_configs3 = __commonJS({
       return false;
     }
     function isCJSRequire(node) {
-      if (node.type === utils$1.AST_NODE_TYPES.VariableDeclaration) {
+      if (node.type === utils.AST_NODE_TYPES.VariableDeclaration) {
         const declaration = node.declarations[0];
         if (declaration?.init) {
           let call = declaration?.init;
-          while (call.type === utils$1.AST_NODE_TYPES.MemberExpression)
+          while (call.type === utils.AST_NODE_TYPES.MemberExpression)
             call = call.object;
-          if (call.type === utils$1.AST_NODE_TYPES.CallExpression && call.callee.type === utils$1.AST_NODE_TYPES.Identifier) {
+          if (call.type === utils.AST_NODE_TYPES.CallExpression && call.callee.type === utils.AST_NODE_TYPES.Identifier) {
             return call.callee.name === "require";
           }
         }
@@ -18953,17 +19093,17 @@ var require_configs3 = __commonJS({
       return false;
     }
     function isBlockLikeStatement(node, sourceCode) {
-      if (node.type === utils$1.AST_NODE_TYPES.DoWhileStatement && node.body.type === utils$1.AST_NODE_TYPES.BlockStatement) {
+      if (node.type === utils.AST_NODE_TYPES.DoWhileStatement && node.body.type === utils.AST_NODE_TYPES.BlockStatement) {
         return true;
       }
       if (isIIFEStatement(node))
         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$1.AST_NODE_TYPES.BlockStatement || belongingNode.type === utils$1.AST_NODE_TYPES.SwitchStatement);
+      return !!belongingNode && (belongingNode.type === utils.AST_NODE_TYPES.BlockStatement || belongingNode.type === utils.AST_NODE_TYPES.SwitchStatement);
     }
     function isDirective(node, sourceCode) {
-      return node.type === utils$1.AST_NODE_TYPES.ExpressionStatement && (node.parent?.type === utils$1.AST_NODE_TYPES.Program || node.parent?.type === utils$1.AST_NODE_TYPES.BlockStatement && astUtils.isFunction(node.parent.parent)) && node.expression.type === utils$1.AST_NODE_TYPES.Literal && typeof node.expression.value === "string" && !astUtils.isParenthesized(node.expression, 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);
     }
     function isDirectivePrologue(node, sourceCode) {
       if (isDirective(node, sourceCode) && node.parent && "body" in node.parent && Array.isArray(node.parent.body)) {
@@ -18978,21 +19118,21 @@ var require_configs3 = __commonJS({
       return false;
     }
     function isCJSExport(node) {
-      if (node.type === utils$1.AST_NODE_TYPES.ExpressionStatement) {
+      if (node.type === utils.AST_NODE_TYPES.ExpressionStatement) {
         const expression = node.expression;
-        if (expression.type === utils$1.AST_NODE_TYPES.AssignmentExpression) {
+        if (expression.type === utils.AST_NODE_TYPES.AssignmentExpression) {
           let left = expression.left;
-          if (left.type === utils$1.AST_NODE_TYPES.MemberExpression) {
-            while (left.object.type === utils$1.AST_NODE_TYPES.MemberExpression)
+          if (left.type === utils.AST_NODE_TYPES.MemberExpression) {
+            while (left.object.type === utils.AST_NODE_TYPES.MemberExpression)
               left = left.object;
-            return left.object.type === utils$1.AST_NODE_TYPES.Identifier && (left.object.name === "exports" || left.object.name === "module" && left.property.type === utils$1.AST_NODE_TYPES.Identifier && left.property.name === "exports");
+            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 false;
     }
     function isExpression(node, sourceCode) {
-      return node.type === utils$1.AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode);
+      return node.type === utils.AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode);
     }
     function getActualLastToken(node, sourceCode) {
       const semiToken = sourceCode.getLastToken(node);
@@ -19085,7 +19225,7 @@ var require_configs3 = __commonJS({
         test: (node, sourceCode) => node.loc.start.line !== node.loc.end.line && isBlockLikeStatement(node, sourceCode)
       },
       "multiline-expression": {
-        test: (node, sourceCode) => node.loc.start.line !== node.loc.end.line && node.type === utils$1.AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode)
+        test: (node, sourceCode) => node.loc.start.line !== node.loc.end.line && node.type === utils.AST_NODE_TYPES.ExpressionStatement && !isDirectivePrologue(node, sourceCode)
       },
       "multiline-const": newMultilineKeywordTester("const"),
       "multiline-let": newMultilineKeywordTester("let"),
@@ -19093,49 +19233,49 @@ var require_configs3 = __commonJS({
       "singleline-const": newSinglelineKeywordTester("const"),
       "singleline-let": newSinglelineKeywordTester("let"),
       "singleline-var": newSinglelineKeywordTester("var"),
-      "block": newNodeTypeTester(utils$1.AST_NODE_TYPES.BlockStatement),
-      "empty": newNodeTypeTester(utils$1.AST_NODE_TYPES.EmptyStatement),
-      "function": newNodeTypeTester(utils$1.AST_NODE_TYPES.FunctionDeclaration),
-      "break": newKeywordTester(utils$1.AST_NODE_TYPES.BreakStatement, "break"),
-      "case": newKeywordTester(utils$1.AST_NODE_TYPES.SwitchCase, "case"),
-      "class": newKeywordTester(utils$1.AST_NODE_TYPES.ClassDeclaration, "class"),
-      "const": newKeywordTester(utils$1.AST_NODE_TYPES.VariableDeclaration, "const"),
-      "continue": newKeywordTester(utils$1.AST_NODE_TYPES.ContinueStatement, "continue"),
-      "debugger": newKeywordTester(utils$1.AST_NODE_TYPES.DebuggerStatement, "debugger"),
+      "block": newNodeTypeTester(utils.AST_NODE_TYPES.BlockStatement),
+      "empty": newNodeTypeTester(utils.AST_NODE_TYPES.EmptyStatement),
+      "function": newNodeTypeTester(utils.AST_NODE_TYPES.FunctionDeclaration),
+      "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"),
       "default": newKeywordTester(
-        [utils$1.AST_NODE_TYPES.SwitchCase, utils$1.AST_NODE_TYPES.ExportDefaultDeclaration],
+        [utils.AST_NODE_TYPES.SwitchCase, utils.AST_NODE_TYPES.ExportDefaultDeclaration],
         "default"
       ),
-      "do": newKeywordTester(utils$1.AST_NODE_TYPES.DoWhileStatement, "do"),
+      "do": newKeywordTester(utils.AST_NODE_TYPES.DoWhileStatement, "do"),
       "export": newKeywordTester(
         [
-          utils$1.AST_NODE_TYPES.ExportAllDeclaration,
-          utils$1.AST_NODE_TYPES.ExportDefaultDeclaration,
-          utils$1.AST_NODE_TYPES.ExportNamedDeclaration
+          utils.AST_NODE_TYPES.ExportAllDeclaration,
+          utils.AST_NODE_TYPES.ExportDefaultDeclaration,
+          utils.AST_NODE_TYPES.ExportNamedDeclaration
         ],
         "export"
       ),
       "for": newKeywordTester(
         [
-          utils$1.AST_NODE_TYPES.ForStatement,
-          utils$1.AST_NODE_TYPES.ForInStatement,
-          utils$1.AST_NODE_TYPES.ForOfStatement
+          utils.AST_NODE_TYPES.ForStatement,
+          utils.AST_NODE_TYPES.ForInStatement,
+          utils.AST_NODE_TYPES.ForOfStatement
         ],
         "for"
       ),
-      "if": newKeywordTester(utils$1.AST_NODE_TYPES.IfStatement, "if"),
-      "import": newKeywordTester(utils$1.AST_NODE_TYPES.ImportDeclaration, "import"),
-      "let": newKeywordTester(utils$1.AST_NODE_TYPES.VariableDeclaration, "let"),
-      "return": newKeywordTester(utils$1.AST_NODE_TYPES.ReturnStatement, "return"),
-      "switch": newKeywordTester(utils$1.AST_NODE_TYPES.SwitchStatement, "switch"),
-      "throw": newKeywordTester(utils$1.AST_NODE_TYPES.ThrowStatement, "throw"),
-      "try": newKeywordTester(utils$1.AST_NODE_TYPES.TryStatement, "try"),
-      "var": newKeywordTester(utils$1.AST_NODE_TYPES.VariableDeclaration, "var"),
+      "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"),
       "while": newKeywordTester(
-        [utils$1.AST_NODE_TYPES.WhileStatement, utils$1.AST_NODE_TYPES.DoWhileStatement],
+        [utils.AST_NODE_TYPES.WhileStatement, utils.AST_NODE_TYPES.DoWhileStatement],
         "while"
       ),
-      "with": newKeywordTester(utils$1.AST_NODE_TYPES.WithStatement, "with"),
+      "with": newKeywordTester(utils.AST_NODE_TYPES.WithStatement, "with"),
       "cjs-export": {
         test: (node, sourceCode) => node.type === "ExpressionStatement" && node.expression.type === "AssignmentExpression" && CJS_EXPORT.test(sourceCode.getText(node.expression.left))
       },
@@ -19143,25 +19283,28 @@ var require_configs3 = __commonJS({
         test: (node, sourceCode) => node.type === "VariableDeclaration" && node.declarations.length > 0 && Boolean(node.declarations[0].init) && CJS_IMPORT.test(sourceCode.getText(node.declarations[0].init))
       },
       // Additional Typescript constructs
+      "enum": newKeywordTester(
+        utils.AST_NODE_TYPES.TSEnumDeclaration,
+        "enum"
+      ),
       "interface": newKeywordTester(
-        utils$1.AST_NODE_TYPES.TSInterfaceDeclaration,
+        utils.AST_NODE_TYPES.TSInterfaceDeclaration,
         "interface"
       ),
       "type": newKeywordTester(
-        utils$1.AST_NODE_TYPES.TSTypeAliasDeclaration,
+        utils.AST_NODE_TYPES.TSTypeAliasDeclaration,
         "type"
       ),
       "function-overload": {
         test: (node) => node.type === "TSDeclareFunction"
       }
     };
-    var paddingLineBetweenStatements = utils.createRule({
+    var paddingLineBetweenStatements = utils$1.createRule({
       name: "padding-line-between-statements",
       meta: {
         type: "layout",
         docs: {
-          description: "Require or disallow padding lines between statements",
-          extendsBaseRule: true
+          description: "Require or disallow padding lines between statements"
         },
         fixable: "whitespace",
         hasSuggestions: false,
@@ -19226,7 +19369,7 @@ var require_configs3 = __commonJS({
         }
         function match(node, type) {
           let innerStatementNode = node;
-          while (innerStatementNode.type === utils$1.AST_NODE_TYPES.LabeledStatement)
+          while (innerStatementNode.type === utils.AST_NODE_TYPES.LabeledStatement)
             innerStatementNode = innerStatementNode.body;
           if (Array.isArray(type))
             return type.some(match.bind(null, innerStatementNode));
@@ -19258,11 +19401,11 @@ var require_configs3 = __commonJS({
         }
         function verify(node) {
           if (!node.parent || ![
-            utils$1.AST_NODE_TYPES.BlockStatement,
-            utils$1.AST_NODE_TYPES.Program,
-            utils$1.AST_NODE_TYPES.SwitchCase,
-            utils$1.AST_NODE_TYPES.SwitchStatement,
-            utils$1.AST_NODE_TYPES.TSModuleBlock
+            utils.AST_NODE_TYPES.BlockStatement,
+            utils.AST_NODE_TYPES.Program,
+            utils.AST_NODE_TYPES.SwitchCase,
+            utils.AST_NODE_TYPES.SwitchStatement,
+            utils.AST_NODE_TYPES.TSModuleBlock
           ].includes(node.parent.type)) {
             return;
           }
@@ -19295,23 +19438,33 @@ var require_configs3 = __commonJS({
         };
       }
     });
-    var baseRule$4 = utils.getESLintCoreRule("quote-props");
+    module2.exports = paddingLineBetweenStatements;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/quote-props.js
+var require_quote_props2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/quote-props.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("quote-props");
     var quoteProps = utils.createRule({
       name: "quote-props",
       meta: {
-        ...baseRule$4.meta,
+        ...baseRule.meta,
         docs: {
-          description: "Require quotes around object literal, type literal, interfaces and enums property names",
-          extendsBaseRule: true
+          description: "Require quotes around object literal, type literal, interfaces and enums property names"
         }
       },
       defaultOptions: ["always"],
       create(context) {
-        const rules2 = baseRule$4.create(context);
+        const rules = baseRule.create(context);
         return {
-          ...rules2,
+          ...rules,
           TSPropertySignature(node) {
-            return rules2.Property({
+            return rules.Property({
               ...node,
               type: utils$1.AST_NODE_TYPES.Property,
               shorthand: false,
@@ -19321,7 +19474,7 @@ var require_configs3 = __commonJS({
             });
           },
           TSMethodSignature(node) {
-            return rules2.Property({
+            return rules.Property({
               ...node,
               type: utils$1.AST_NODE_TYPES.Property,
               shorthand: false,
@@ -19331,7 +19484,7 @@ var require_configs3 = __commonJS({
             });
           },
           TSEnumMember(node) {
-            return rules2.Property({
+            return rules.Property({
               ...node,
               type: utils$1.AST_NODE_TYPES.Property,
               key: node.id,
@@ -19343,42 +19496,53 @@ var require_configs3 = __commonJS({
             });
           },
           TSTypeLiteral(node) {
-            return rules2.ObjectExpression({
+            return rules.ObjectExpression({
               ...node,
               type: utils$1.AST_NODE_TYPES.ObjectExpression,
               properties: node.members
             });
           },
           TSInterfaceBody(node) {
-            return rules2.ObjectExpression({
+            return rules.ObjectExpression({
               ...node,
               type: utils$1.AST_NODE_TYPES.ObjectExpression,
               properties: node.body
             });
           },
           TSEnumDeclaration(node) {
-            return rules2.ObjectExpression({
+            const members = node.body?.members || node.members;
+            return rules.ObjectExpression({
               ...node,
               type: utils$1.AST_NODE_TYPES.ObjectExpression,
-              properties: node.members.map((member) => ({ ...member, key: member.id }))
+              properties: members.map((member) => ({ ...member, key: member.id }))
             });
           }
         };
       }
     });
-    var baseRule$3 = utils.getESLintCoreRule("quotes");
+    module2.exports = quoteProps;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/quotes.js
+var require_quotes2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/quotes.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("quotes");
     var quotes = utils.createRule({
       name: "quotes",
       meta: {
         type: "layout",
         docs: {
-          description: "Enforce the consistent use of either backticks, double, or single quotes",
-          extendsBaseRule: true
+          description: "Enforce the consistent use of either backticks, double, or single quotes"
         },
         fixable: "code",
-        hasSuggestions: baseRule$3.meta.hasSuggestions,
-        messages: baseRule$3.meta.messages,
-        schema: baseRule$3.meta.schema
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        messages: baseRule.meta.messages,
+        schema: baseRule.meta.schema
       },
       defaultOptions: [
         "double",
@@ -19389,7 +19553,7 @@ var require_configs3 = __commonJS({
         }
       ],
       create(context, [option]) {
-        const rules2 = baseRule$3.create(context);
+        const rules = baseRule.create(context);
         function isAllowedAsNonBacktick(node) {
           const parent = node.parent;
           switch (parent?.type) {
@@ -19412,28 +19576,38 @@ var require_configs3 = __commonJS({
           Literal(node) {
             if (option === "backtick" && isAllowedAsNonBacktick(node))
               return;
-            rules2.Literal(node);
+            rules.Literal(node);
           },
           TemplateLiteral(node) {
-            rules2.TemplateLiteral(node);
+            rules.TemplateLiteral(node);
           }
         };
       }
     });
-    var baseRule$2 = utils.getESLintCoreRule("semi");
+    module2.exports = quotes;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/semi.js
+var require_semi2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/semi.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("semi");
     var semi = utils.createRule({
       name: "semi",
       meta: {
         type: "layout",
         docs: {
-          description: "Require or disallow semicolons instead of ASI",
+          description: "Require or disallow semicolons instead of ASI"
           // too opinionated to be recommended
-          extendsBaseRule: true
         },
         fixable: "code",
-        hasSuggestions: baseRule$2.meta.hasSuggestions,
-        schema: baseRule$2.meta.schema,
-        messages: baseRule$2.meta.messages
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: baseRule.meta.schema,
+        messages: baseRule.meta.messages
       },
       defaultOptions: [
         "always",
@@ -19443,8 +19617,8 @@ var require_configs3 = __commonJS({
         }
       ],
       create(context) {
-        const rules2 = baseRule$2.create(context);
-        const checkForSemicolon = rules2.ExpressionStatement;
+        const rules = baseRule.create(context);
+        const checkForSemicolon = rules.ExpressionStatement;
         const nodesToCheck = [
           utils$1.AST_NODE_TYPES.PropertyDefinition,
           utils$1.AST_NODE_TYPES.TSAbstractPropertyDefinition,
@@ -19458,41 +19632,52 @@ var require_configs3 = __commonJS({
           return acc;
         }, {});
         return {
-          ...rules2,
+          ...rules,
           ...nodesToCheck,
           ExportDefaultDeclaration(node) {
             if (node.declaration.type !== utils$1.AST_NODE_TYPES.TSInterfaceDeclaration)
-              rules2.ExportDefaultDeclaration(node);
+              rules.ExportDefaultDeclaration(node);
           }
         };
       }
     });
-    var baseRule$1 = utils.getESLintCoreRule("space-before-blocks");
+    module2.exports = semi;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/space-before-blocks.js
+var require_space_before_blocks2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/space-before-blocks.js"(exports2, module2) {
+    "use strict";
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
+    var baseRule = utils.getESLintCoreRule("space-before-blocks");
     var spaceBeforeBlocks = utils.createRule({
       name: "space-before-blocks",
       meta: {
         type: "layout",
         docs: {
-          description: "Enforce consistent spacing before blocks",
-          extendsBaseRule: true
+          description: "Enforce consistent spacing before blocks"
         },
-        fixable: baseRule$1.meta.fixable,
-        hasSuggestions: baseRule$1.meta.hasSuggestions,
-        schema: baseRule$1.meta.schema,
+        fixable: baseRule.meta.fixable,
+        hasSuggestions: baseRule.meta.hasSuggestions,
+        schema: baseRule.meta.schema,
         messages: {
           unexpectedSpace: "Unexpected space before opening brace.",
           missingSpace: "Missing space before opening brace.",
-          ...baseRule$1.meta.messages
+          ...baseRule.meta.messages
         }
       },
       defaultOptions: ["always"],
-      create(context, [config2]) {
-        const rules2 = baseRule$1.create(context);
+      create(context, [config]) {
+        const rules = baseRule.create(context);
         const sourceCode = context.sourceCode;
         let requireSpace = true;
-        if (typeof config2 === "object")
-          requireSpace = config2.classes === "always";
-        else if (config2 === "never")
+        if (typeof config === "object")
+          requireSpace = config.classes === "always";
+        else if (config === "never")
           requireSpace = false;
         function checkPrecedingSpace(node) {
           const precedingToken = sourceCode.getTokenBefore(node);
@@ -19529,19 +19714,30 @@ var require_configs3 = __commonJS({
             checkPrecedingSpace(punctuator);
         }
         return {
-          ...rules2,
+          ...rules,
           TSEnumDeclaration: checkSpaceAfterEnum,
           TSInterfaceBody: checkPrecedingSpace
         };
       }
     });
+    module2.exports = spaceBeforeBlocks;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/space-before-function-paren.js
+var require_space_before_function_paren2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/space-before-function-paren.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils = require_utils3();
+    require_dist();
     var spaceBeforeFunctionParen = utils.createRule({
       name: "space-before-function-paren",
       meta: {
         type: "layout",
         docs: {
-          description: "Enforce consistent spacing before function parenthesis",
-          extendsBaseRule: true
+          description: "Enforce consistent spacing before function parenthesis"
         },
         fixable: "whitespace",
         schema: [
@@ -19642,6 +19838,18 @@ var require_configs3 = __commonJS({
         };
       }
     });
+    module2.exports = spaceBeforeFunctionParen;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/space-infix-ops.js
+var require_space_infix_ops2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/space-infix-ops.js"(exports2, module2) {
+    "use strict";
+    var utils$1 = require("@typescript-eslint/utils");
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    var utils = require_utils3();
+    require_dist();
     var baseRule = utils.getESLintCoreRule("space-infix-ops");
     var UNIONS = ["|", "&"];
     var spaceInfixOps = utils.createRule({
@@ -19649,8 +19857,7 @@ var require_configs3 = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Require spacing around infix operators",
-          extendsBaseRule: true
+          description: "Require spacing around infix operators"
         },
         fixable: baseRule.meta.fixable,
         hasSuggestions: baseRule.meta.hasSuggestions,
@@ -19666,7 +19873,7 @@ var require_configs3 = __commonJS({
         }
       ],
       create(context) {
-        const rules2 = baseRule.create(context);
+        const rules = baseRule.create(context);
         const sourceCode = context.sourceCode;
         function report(operator) {
           context.report({
@@ -19740,7 +19947,7 @@ var require_configs3 = __commonJS({
           checkAndReportAssignmentSpace(node.trueType, node.falseType);
         }
         return {
-          ...rules2,
+          ...rules,
           TSEnumMember: checkForEnumAssignmentSpace,
           PropertyDefinition: checkForPropertyDefinitionAssignmentSpace,
           TSTypeAliasDeclaration: checkForTypeAliasAssignment,
@@ -19750,6 +19957,18 @@ var require_configs3 = __commonJS({
         };
       }
     });
+    module2.exports = spaceInfixOps;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/type-annotation-spacing.js
+var require_type_annotation_spacing = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/type-annotation-spacing.js"(exports2, module2) {
+    "use strict";
+    var astUtils = require("@typescript-eslint/utils/ast-utils");
+    require("@typescript-eslint/utils");
+    var utils = require_utils3();
+    require_dist();
     function createRules(options) {
       const globals = {
         ...options?.before !== void 0 ? { before: options.before } : {},
@@ -19775,25 +19994,25 @@ var require_configs3 = __commonJS({
         returnType: { ...colon, ...override?.returnType }
       };
     }
-    function getIdentifierRules(rules2, node) {
+    function getIdentifierRules(rules, node) {
       const scope = node?.parent;
       if (astUtils.isVariableDeclarator(scope))
-        return rules2.variable;
+        return rules.variable;
       else if (astUtils.isFunctionOrFunctionType(scope))
-        return rules2.parameter;
-      return rules2.colon;
+        return rules.parameter;
+      return rules.colon;
     }
-    function getRules(rules2, node) {
+    function getRules(rules, node) {
       const scope = node?.parent?.parent;
       if (astUtils.isTSFunctionType(scope) || astUtils.isTSConstructorType(scope))
-        return rules2.arrow;
+        return rules.arrow;
       else if (astUtils.isIdentifier(scope))
-        return getIdentifierRules(rules2, scope);
+        return getIdentifierRules(rules, scope);
       else if (astUtils.isClassOrTypeElement(scope))
-        return rules2.property;
+        return rules.property;
       else if (astUtils.isFunction(scope))
-        return rules2.returnType;
-      return rules2.colon;
+        return rules.returnType;
+      return rules.colon;
     }
     var typeAnnotationSpacing = utils.createRule({
       name: "type-annotation-spacing",
@@ -19956,6 +20175,38 @@ var require_configs3 = __commonJS({
         };
       }
     });
+    module2.exports = typeAnnotationSpacing;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/index2.js
+var require_index2 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/index2.js"(exports2) {
+    "use strict";
+    var blockSpacing = require_block_spacing2();
+    var braceStyle = require_brace_style2();
+    var commaDangle = require_comma_dangle2();
+    var commaSpacing = require_comma_spacing2();
+    var functionCallSpacing = require_function_call_spacing2();
+    var indent = require_indent2();
+    var keySpacing = require_key_spacing2();
+    var keywordSpacing = require_keyword_spacing2();
+    var linesAroundComment = require_lines_around_comment2();
+    var linesBetweenClassMembers = require_lines_between_class_members2();
+    var memberDelimiterStyle = require_member_delimiter_style();
+    var noExtraParens = require_no_extra_parens2();
+    var noExtraSemi = require_no_extra_semi2();
+    var objectCurlyNewline = require_object_curly_newline2();
+    var objectCurlySpacing = require_object_curly_spacing2();
+    var objectPropertyNewline = require_object_property_newline2();
+    var paddingLineBetweenStatements = require_padding_line_between_statements2();
+    var quoteProps = require_quote_props2();
+    var quotes = require_quotes2();
+    var semi = require_semi2();
+    var spaceBeforeBlocks = require_space_before_blocks2();
+    var spaceBeforeFunctionParen = require_space_before_function_paren2();
+    var spaceInfixOps = require_space_infix_ops2();
+    var typeAnnotationSpacing = require_type_annotation_spacing();
     var rules = {
       "block-spacing": blockSpacing,
       "brace-style": braceStyle,
@@ -19983,8 +20234,40 @@ var require_configs3 = __commonJS({
       "space-infix-ops": spaceInfixOps,
       "type-annotation-spacing": typeAnnotationSpacing
     };
+    exports2.rules = rules;
+  }
+});
+// node_modules/@stylistic/eslint-plugin-ts/dist/configs.js
+var require_configs3 = __commonJS({
+  "node_modules/@stylistic/eslint-plugin-ts/dist/configs.js"(exports2) {
+    "use strict";
+    var index2 = require_index2();
+    function createAllConfigs(plugin2, name, flat, filter) {
+      const rules = Object.fromEntries(
+        Object.entries(plugin2.rules).filter(
+          ([key, rule]) => (
+            // Only include fixable rules
+            rule.meta.fixable && !rule.meta.deprecated && key === rule.meta.docs.url.split("/").pop() && !filter
+          )
+        ).map(([key]) => [`${name}/${key}`, 2])
+      );
+      if (flat) {
+        return {
+          plugins: {
+            [name]: plugin2
+          },
+          rules
+        };
+      } else {
+        return {
+          plugins: [name],
+          rules
+        };
+      }
+    }
     var plugin = {
-      rules
+      rules: index2.rules
     };
     var config = {
       rules: {
@@ -20019,32 +20302,8 @@ var require_configs3 = __commonJS({
       "all-flat": createAllConfigs(plugin, "@stylistic/ts", true),
       "all-extends": createAllConfigs(plugin, "@stylistic/ts", false)
     };
-    exports2.blockSpacing = blockSpacing;
-    exports2.braceStyle = braceStyle;
-    exports2.commaDangle = commaDangle;
-    exports2.commaSpacing = commaSpacing;
     exports2.configs = configs2;
-    exports2.functionCallSpacing = functionCallSpacing;
-    exports2.indent = indent;
-    exports2.keySpacing = keySpacing;
-    exports2.keywordSpacing = keywordSpacing;
-    exports2.linesAroundComment = linesAroundComment;
-    exports2.linesBetweenClassMembers = linesBetweenClassMembers;
-    exports2.memberDelimiterStyle = memberDelimiterStyle;
-    exports2.noExtraParens = noExtraParens;
-    exports2.noExtraSemi = noExtraSemi;
-    exports2.objectCurlyNewline = objectCurlyNewline;
-    exports2.objectCurlySpacing = objectCurlySpacing;
-    exports2.objectPropertyNewline = objectPropertyNewline;
-    exports2.paddingLineBetweenStatements = paddingLineBetweenStatements;
     exports2.plugin = plugin;
-    exports2.quoteProps = quoteProps;
-    exports2.quotes = quotes;
-    exports2.semi = semi;
-    exports2.spaceBeforeBlocks = spaceBeforeBlocks;
-    exports2.spaceBeforeFunctionParen = spaceBeforeFunctionParen;
-    exports2.spaceInfixOps = spaceInfixOps;
-    exports2.typeAnnotationSpacing = typeAnnotationSpacing;
   }
 });
@@ -20053,10 +20312,35 @@ var require_dist3 = __commonJS({
   "node_modules/@stylistic/eslint-plugin-ts/dist/index.js"(exports2, module2) {
     "use strict";
     var configs2 = require_configs3();
+    require_index2();
+    require_block_spacing2();
     require("@typescript-eslint/utils");
     require("@typescript-eslint/utils/ast-utils");
     require_utils3();
     require_dist();
+    require_brace_style2();
+    require_comma_dangle2();
+    require_comma_spacing2();
+    require_function_call_spacing2();
+    require_indent2();
+    require_key_spacing2();
+    require_keyword_spacing2();
+    require_lines_around_comment2();
+    require_lines_between_class_members2();
+    require_member_delimiter_style();
+    require_no_extra_parens2();
+    require_no_extra_semi2();
+    require_object_curly_newline2();
+    require_object_curly_spacing2();
+    require_object_property_newline2();
+    require_padding_line_between_statements2();
+    require_quote_props2();
+    require_quotes2();
+    require_semi2();
+    require_space_before_blocks2();
+    require_space_before_function_paren2();
+    require_space_infix_ops2();
+    require_type_annotation_spacing();
     var index2 = Object.assign(configs2.plugin, { configs: configs2.configs });
     module2.exports = index2;
   }
@@ -20085,8 +20369,7 @@ var require_indent_binary_ops = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Indentation for binary operators",
-          recommended: "stylistic"
+          description: "Indentation for binary operators"
         },
         fixable: "whitespace",
         schema: [
@@ -20216,8 +20499,7 @@ var require_type_generic_spacing = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Enforces consistent spacing inside TypeScript type generics",
-          recommended: "stylistic"
+          description: "Enforces consistent spacing inside TypeScript type generics"
         },
         fixable: "whitespace",
         schema: [],
@@ -20272,10 +20554,11 @@ var require_type_generic_spacing = __commonJS({
             const endNode = node.constraint || node.name;
             const from = endNode.range[1];
             const to = node.default.range[0];
-            if (sourceCode.text.slice(from, to) !== " = ") {
+            const span = sourceCode.text.slice(from, to);
+            if (!span.match(/(?:^|[^ ]) = (?:$|[^ ])/)) {
               context.report({
                 *fix(fixer) {
-                  yield fixer.replaceTextRange([from, to], " = ");
+                  yield fixer.replaceTextRange([from, to], span.replace(/\s*=\s*/, " = "));
                 },
                 loc: {
                   start: endNode.loc.end,
@@ -20305,8 +20588,7 @@ var require_type_named_tuple_spacing = __commonJS({
       meta: {
         type: "layout",
         docs: {
-          description: "Expect space before the type declaration in the named tuple",
-          recommended: "stylistic"
+          description: "Expect space before the type declaration in the named tuple"
         },
         fixable: "whitespace",
         schema: [],