@flint.fyi/ts 0.14.6 → 0.15.0

package/lib/rules/returnAssignments.js

@@ -22,29 +22,30 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkForAssignment(node) {
+        function checkForAssignment(node, sourceFile) {
             const unwrapped = unwrapParenthesizedExpression(node);
             if (ts.isBinaryExpression(unwrapped) &&
                 tsutils.isAssignmentKind(unwrapped.operatorToken.kind)) {
                 context.report({
                     message: "noReturnAssign",
-                    range: getTSNodeRange(unwrapped.operatorToken, context.sourceFile),
+                    range: getTSNodeRange(unwrapped.operatorToken, sourceFile),
                 });
             }
         }
         return {
             visitors: {
-                ArrowFunction: (node) => {
+                ArrowFunction: (node, { sourceFile }) => {
                     if (!ts.isBlock(node.body)) {
-                        checkForAssignment(node.body);
+                        checkForAssignment(node.body, sourceFile);
                     }
                 },
-                ReturnStatement: (node) => {
+                ReturnStatement: (node, { sourceFile }) => {
                     if (node.expression) {
-                        checkForAssignment(node.expression);
+                        checkForAssignment(node.expression, sourceFile);
                     }
                 },
             },
         };
     },
 });
+//# sourceMappingURL=returnAssignments.js.map

package/lib/rules/returnAssignments.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=returnAssignments.test.d.ts.map

package/lib/rules/returnAssignments.test.js

@@ -183,3 +183,4 @@ function arrowReturn() {
 `,
     ],
 });
+//# sourceMappingURL=returnAssignments.test.js.map

package/lib/rules/ruleTester.d.ts

@@ -1,2 +1,3 @@
 import { RuleTester } from "@flint.fyi/rule-tester";
 export declare const ruleTester: RuleTester;
+//# sourceMappingURL=ruleTester.d.ts.map

package/lib/rules/ruleTester.js

@@ -1,3 +1,8 @@
 import { RuleTester } from "@flint.fyi/rule-tester";
 import { describe, it } from "vitest";
-export const ruleTester = new RuleTester({ describe, it });
+export const ruleTester = new RuleTester({
+    defaults: { fileName: "file.ts" },
+    describe,
+    it,
+});
+//# sourceMappingURL=ruleTester.js.map

package/lib/rules/selfAssignments.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports self-assignments which have no effect and are likely errors.";
     readonly id: "selfAssignments";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "selfAssignment", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "selfAssignment", undefined>;
 export default _default;
+//# sourceMappingURL=selfAssignments.d.ts.map

package/lib/rules/selfAssignments.js

@@ -22,7 +22,7 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                BinaryExpression: (node) => {
+                BinaryExpression: (node, { sourceFile }) => {
                     if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken &&
                         node.operatorToken.kind !==
                             ts.SyntaxKind.AmpersandAmpersandEqualsToken &&
@@ -31,10 +31,10 @@ export default typescriptLanguage.createRule({
                             ts.SyntaxKind.QuestionQuestionEqualsToken) {
                         return;
                     }
-                    if (hasSameTokens(node.left, node.right, context.sourceFile)) {
+                    if (hasSameTokens(node.left, node.right, sourceFile)) {
                         context.report({
                             message: "selfAssignment",
-                            range: getTSNodeRange(node, context.sourceFile),
+                            range: getTSNodeRange(node, sourceFile),
                         });
                     }
                 },
@@ -42,3 +42,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=selfAssignments.js.map

package/lib/rules/selfAssignments.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=selfAssignments.test.d.ts.map

package/lib/rules/selfAssignments.test.js

@@ -64,3 +64,4 @@ This value is being assigned to itself, which does nothing.
         `a.b ||= a.c;`,
     ],
 });
+//# sourceMappingURL=selfAssignments.test.js.map

package/lib/rules/selfComparisons.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports comparing a value to itself.";
     readonly id: "selfComparisons";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noSelfComparison", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noSelfComparison", undefined>;
 export default _default;
+//# sourceMappingURL=selfComparisons.d.ts.map

package/lib/rules/selfComparisons.js

@@ -23,13 +23,13 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                BinaryExpression: (node) => {
+                BinaryExpression: (node, { sourceFile }) => {
                     if (isComparisonOperator(node.operatorToken) &&
-                        hasSameTokens(node.left, node.right, context.sourceFile)) {
+                        hasSameTokens(node.left, node.right, sourceFile)) {
                         context.report({
                             message: "noSelfComparison",
                             range: {
-                                begin: node.getStart(context.sourceFile),
+                                begin: node.getStart(sourceFile),
                                 end: node.getEnd(),
                             },
                         });
@@ -39,3 +39,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=selfComparisons.js.map

package/lib/rules/selfComparisons.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=selfComparisons.test.d.ts.map

package/lib/rules/selfComparisons.test.js

@@ -295,3 +295,4 @@ const result = value /* a */ /* b */ === value /* c */ /* d */;
         `const result = value1 /* a */ /* b */ === value2 /* c */ /* d */;`,
     ],
 });
+//# sourceMappingURL=selfComparisons.test.js.map

package/lib/rules/sequences.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using the comma operator in expressions.";
     readonly id: "sequences";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noSequences", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noSequences", undefined>;
 export default _default;
+//# sourceMappingURL=sequences.d.ts.map

package/lib/rules/sequences.js

@@ -20,11 +20,11 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                BinaryExpression: (node) => {
+                BinaryExpression: (node, { sourceFile }) => {
                     if (node.operatorToken.kind === ts.SyntaxKind.CommaToken) {
                         context.report({
                             message: "noSequences",
-                            range: getTSNodeRange(node.operatorToken, context.sourceFile),
+                            range: getTSNodeRange(node.operatorToken, sourceFile),
                         });
                     }
                 },
@@ -32,3 +32,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=sequences.js.map

package/lib/rules/sequences.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=sequences.test.d.ts.map

package/lib/rules/sequences.test.js

@@ -46,3 +46,4 @@ for ((a = 1, b = 2); ; ) {
         `for (let i = 0; i < 10; i += 1) {}`,
     ],
 });
+//# sourceMappingURL=sequences.test.js.map

package/lib/rules/shadowedRestrictedNames.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports variable declarations that shadow JavaScript's restricted names.";
     readonly id: "shadowedRestrictedNames";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "shadowedRestrictedName", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "shadowedRestrictedName", undefined>;
 export default _default;
+//# sourceMappingURL=shadowedRestrictedNames.d.ts.map

package/lib/rules/shadowedRestrictedNames.js

@@ -27,69 +27,70 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkIdentifier(node) {
+        function checkIdentifier(node, sourceFile) {
             if (restrictedNames.has(node.text)) {
                 context.report({
                     data: {
                         name: node.text,
                     },
                     message: "shadowedRestrictedName",
-                    range: getTSNodeRange(node, context.sourceFile),
+                    range: getTSNodeRange(node, sourceFile),
                 });
             }
         }
-        function checkBindingName(name) {
+        function checkBindingName(name, sourceFile) {
             if (ts.isIdentifier(name)) {
-                checkIdentifier(name);
+                checkIdentifier(name, sourceFile);
             }
             else if (ts.isObjectBindingPattern(name) ||
                 ts.isArrayBindingPattern(name)) {
                 for (const element of name.elements) {
                     if (ts.isBindingElement(element)) {
-                        checkBindingName(element.name);
+                        checkBindingName(element.name, sourceFile);
                     }
                 }
             }
         }
-        function checkParameters(parameters) {
+        function checkParameters(parameters, sourceFile) {
             for (const parameter of parameters) {
-                checkBindingName(parameter.name);
+                checkBindingName(parameter.name, sourceFile);
             }
         }
         return {
             visitors: {
-                ArrowFunction: (node) => {
-                    checkParameters(node.parameters);
+                ArrowFunction: (node, { sourceFile }) => {
+                    checkParameters(node.parameters, sourceFile);
                 },
-                ClassDeclaration: (node) => {
+                ClassDeclaration: (node, { sourceFile }) => {
                     if (node.name) {
-                        checkIdentifier(node.name);
+                        checkIdentifier(node.name, sourceFile);
                     }
                 },
-                ClassExpression: (node) => {
+                ClassExpression: (node, { sourceFile }) => {
                     if (node.name) {
-                        checkIdentifier(node.name);
+                        checkIdentifier(node.name, sourceFile);
                     }
                 },
-                FunctionDeclaration: (node) => {
+                FunctionDeclaration: (node, { sourceFile }) => {
                     if (node.name) {
-                        checkIdentifier(node.name);
+                        checkIdentifier(node.name, sourceFile);
                     }
-                    checkParameters(node.parameters);
+                    checkParameters(node.parameters, sourceFile);
                 },
-                FunctionExpression: (node) => {
+                FunctionExpression: (node, { sourceFile }) => {
                     if (node.name) {
-                        checkIdentifier(node.name);
+                        checkIdentifier(node.name, sourceFile);
                     }
-                    checkParameters(node.parameters);
+                    checkParameters(node.parameters, sourceFile);
                 },
-                MethodDeclaration: (node) => {
-                    checkParameters(node.parameters);
+                MethodDeclaration: (node, { sourceFile }) => {
+                    checkParameters(node.parameters, sourceFile);
                 },
-                VariableDeclaration: (node) => {
-                    checkBindingName(node.name);
+                VariableDeclaration: (node, { sourceFile }) => {
+                    checkBindingName(node.name, sourceFile);
                 },
             },
         };
     },
 });
+//# sourceMappingURL=shadowedRestrictedNames.js.map

package/lib/rules/shadowedRestrictedNames.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=shadowedRestrictedNames.test.d.ts.map

package/lib/rules/shadowedRestrictedNames.test.js

@@ -145,3 +145,4 @@ function test() {
         `obj.undefined = 5;`,
     ],
 });
+//# sourceMappingURL=shadowedRestrictedNames.test.js.map

package/lib/rules/sparseArrays.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports array literals with holes (sparse arrays).";
     readonly id: "sparseArrays";
     readonly preset: "logical";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noSparseArray", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noSparseArray", undefined>;
 export default _default;
+//# sourceMappingURL=sparseArrays.d.ts.map

package/lib/rules/sparseArrays.js

@@ -22,25 +22,25 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                OmittedExpression: (node) => {
+                OmittedExpression: (node, { sourceFile }) => {
                     const parent = node.parent;
                     if (!ts.isArrayLiteralExpression(parent)) {
                         return;
                     }
                     const syntaxList = parent
-                        .getChildren(context.sourceFile)
+                        .getChildren(sourceFile)
                         .find((child) => child.kind === ts.SyntaxKind.SyntaxList);
                     if (!syntaxList) {
                         return;
                     }
-                    const children = syntaxList.getChildren(context.sourceFile);
+                    const children = syntaxList.getChildren(sourceFile);
                     const omittedIndex = children.indexOf(node);
                     for (let i = omittedIndex + 1; i < children.length; i++) {
                         if (children[i].kind === ts.SyntaxKind.CommaToken) {
                             context.report({
                                 message: "noSparseArray",
                                 range: {
-                                    begin: children[i].getStart(context.sourceFile),
+                                    begin: children[i].getStart(sourceFile),
                                     end: children[i].getEnd(),
                                 },
                             });
@@ -52,3 +52,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=sparseArrays.js.map

package/lib/rules/sparseArrays.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=sparseArrays.test.d.ts.map

package/lib/rules/sparseArrays.test.js

@@ -108,3 +108,4 @@ function getArray() {
         `const values = [null, undefined, 0, false, ""];`,
     ],
 });
+//# sourceMappingURL=sparseArrays.test.js.map

package/lib/rules/symbolDescriptions.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports Symbol() calls without description arguments.";
     readonly id: "symbolDescriptions";
     readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "missingDescription", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "missingDescription", undefined>;
 export default _default;
+//# sourceMappingURL=symbolDescriptions.d.ts.map

package/lib/rules/symbolDescriptions.js

@@ -21,7 +21,7 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                CallExpression: (node) => {
+                CallExpression: (node, { sourceFile }) => {
                     if (!ts.isIdentifier(node.expression) ||
                         node.expression.text !== "Symbol" ||
                         node.arguments.length) {
@@ -30,7 +30,7 @@ export default typescriptLanguage.createRule({
                     context.report({
                         message: "missingDescription",
                         range: {
-                            begin: node.getStart(context.sourceFile),
+                            begin: node.getStart(sourceFile),
                             end: node.getEnd(),
                         },
                     });
@@ -39,3 +39,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=symbolDescriptions.js.map

package/lib/rules/symbolDescriptions.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=symbolDescriptions.test.d.ts.map

package/lib/rules/symbolDescriptions.test.js

@@ -87,3 +87,4 @@ const value = condition ? Symbol() : null;
         `Symbol("valid")`,
     ],
 });
+//# sourceMappingURL=symbolDescriptions.test.js.map

package/lib/rules/typeofComparisons.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports typeof expressions that compare impossible string literals.";
     readonly id: "typeofComparisons";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "invalidValue", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "invalidValue", undefined>;
 export default _default;
+//# sourceMappingURL=typeofComparisons.d.ts.map

package/lib/rules/typeofComparisons.js

@@ -40,7 +40,7 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        function checkComparison(node) {
+        function checkComparison(node, sourceFile) {
             const leftTypeofOperand = getTypeofOperand(node.left);
             const rightTypeofOperand = getTypeofOperand(node.right);
             let comparisonValue;
@@ -57,22 +57,23 @@ export default typescriptLanguage.createRule({
             if (stringValue != null && !validTypeofValues.has(stringValue)) {
                 context.report({
                     message: "invalidValue",
-                    range: getTSNodeRange(comparisonValue, context.sourceFile),
+                    range: getTSNodeRange(comparisonValue, sourceFile),
                 });
             }
         }
         return {
             visitors: {
-                BinaryExpression: (node) => {
+                BinaryExpression: (node, { sourceFile }) => {
                     if (node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsToken ||
                         node.operatorToken.kind === ts.SyntaxKind.EqualsEqualsEqualsToken ||
                         node.operatorToken.kind === ts.SyntaxKind.ExclamationEqualsToken ||
                         node.operatorToken.kind ===
                             ts.SyntaxKind.ExclamationEqualsEqualsToken) {
-                        checkComparison(node);
+                        checkComparison(node, sourceFile);
                     }
                 },
             },
         };
     },
 });
+//# sourceMappingURL=typeofComparisons.js.map

package/lib/rules/typeofComparisons.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=typeofComparisons.test.d.ts.map

package/lib/rules/typeofComparisons.test.js

@@ -83,3 +83,4 @@ const isValid = typeof input !== "array";
         `const type = typeof value;`,
     ],
 });
+//# sourceMappingURL=typeofComparisons.test.js.map

package/lib/rules/unassignedVariables.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports variables that are declared but never assigned a value.";
     readonly id: "unassignedVariables";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noUnassigned", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noUnassigned", undefined>;
 export default _default;
+//# sourceMappingURL=unassignedVariables.d.ts.map

package/lib/rules/unassignedVariables.js

@@ -28,7 +28,7 @@ export default typescriptLanguage.createRule({
         }
         return {
             visitors: {
-                VariableDeclaration: (node) => {
+                VariableDeclaration: (node, { sourceFile, typeChecker }) => {
                     if (node.initializer || !ts.isIdentifier(node.name)) {
                         return;
                     }
@@ -36,14 +36,14 @@ export default typescriptLanguage.createRule({
                         !!(node.parent.flags & ts.NodeFlags.Const)) {
                         return;
                     }
-                    if (!hasAssignments(node.name, context.sourceFile, context.typeChecker)) {
+                    if (!hasAssignments(node.name, sourceFile, typeChecker)) {
                         context.report({
                             data: {
                                 name: node.name.text,
                             },
                             message: "noUnassigned",
                             range: {
-                                begin: node.name.getStart(context.sourceFile),
+                                begin: node.name.getStart(sourceFile),
                                 end: node.name.getEnd(),
                             },
                         });
@@ -53,3 +53,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=unassignedVariables.js.map

package/lib/rules/unassignedVariables.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=unassignedVariables.test.d.ts.map

package/lib/rules/unassignedVariables.test.js

@@ -70,3 +70,4 @@ function example() {
         `let nullish; nullish ??= "fallback";`,
     ],
 });
+//# sourceMappingURL=unassignedVariables.test.js.map

package/lib/rules/undefinedVariables.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports using variables that are not defined.";
     readonly id: "undefinedVariables";
     readonly preset: "untyped";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "undefinedVariable", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "undefinedVariable", undefined>;
 export default _default;
+//# sourceMappingURL=undefinedVariables.d.ts.map

package/lib/rules/undefinedVariables.js

@@ -21,7 +21,7 @@ export default typescriptLanguage.createRule({
     setup(context) {
         return {
             visitors: {
-                Identifier: (node) => {
+                Identifier: (node, { sourceFile, typeChecker }) => {
                     if (ts.isVariableDeclaration(node.parent) &&
                         node.parent.name === node) {
                         return;
@@ -56,15 +56,15 @@ export default typescriptLanguage.createRule({
                         return;
                     }
                     // TODO: This rule is untyped, so it should use scope analysis
-                    // https://github.com/JoshuaKGoldberg/flint/issues/400
-                    if (!context.typeChecker.getSymbolAtLocation(node)) {
+                    // https://github.com/flint-fyi/flint/issues/400
+                    if (!typeChecker.getSymbolAtLocation(node)) {
                         context.report({
                             data: {
                                 name: node.text,
                             },
                             message: "undefinedVariable",
                             range: {
-                                begin: node.getStart(context.sourceFile),
+                                begin: node.getStart(sourceFile),
                                 end: node.getEnd(),
                             },
                         });
@@ -74,3 +74,4 @@ export default typescriptLanguage.createRule({
         };
     },
 });
+//# sourceMappingURL=undefinedVariables.js.map

package/lib/rules/undefinedVariables.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=undefinedVariables.test.d.ts.map

package/lib/rules/undefinedVariables.test.js

@@ -78,3 +78,4 @@ const result = first + second;
         `const array = [1, 2, 3]; array.forEach(item => console.log(item));`,
     ],
 });
+//# sourceMappingURL=undefinedVariables.test.js.map

package/lib/rules/unicodeBOMs.d.ts

@@ -2,5 +2,6 @@ declare const _default: import("@flint.fyi/core").Rule<{
     readonly description: "Reports files with Unicode Byte Order Marks (BOMs).";
     readonly id: "unicodeBOMs";
     readonly preset: "stylistic";
-}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptServices, "noBOM", undefined>;
+}, import("../nodes.js").TSNodesByName, import("../language.js").TypeScriptFileServices, "noBOM", undefined>;
 export default _default;
+//# sourceMappingURL=unicodeBOMs.d.ts.map

package/lib/rules/unicodeBOMs.js

@@ -16,26 +16,33 @@ export default typescriptLanguage.createRule({
         },
     },
     setup(context) {
-        const text = context.sourceFile.getFullText();
-        if (text.charCodeAt(0) !== 0xfeff) {
-            return {};
-        }
-        context.report({
-            message: "noBOM",
-            range: {
-                begin: 0,
-                end: 1,
-            },
-            suggestions: [
-                {
-                    id: "removeBOM",
-                    range: {
-                        begin: 0,
-                        end: 1,
-                    },
-                    text: "",
+        return {
+            visitors: {
+                SourceFile: (node) => {
+                    const text = node.getFullText();
+                    if (text.charCodeAt(0) !== 0xfeff) {
+                        return {};
+                    }
+                    context.report({
+                        message: "noBOM",
+                        range: {
+                            begin: 0,
+                            end: 1,
+                        },
+                        suggestions: [
+                            {
+                                id: "removeBOM",
+                                range: {
+                                    begin: 0,
+                                    end: 1,
+                                },
+                                text: "",
+                            },
+                        ],
+                    });
                 },
-            ],
-        });
+            },
+        };
     },
 });
+//# sourceMappingURL=unicodeBOMs.js.map

package/lib/rules/unicodeBOMs.test.d.ts

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=unicodeBOMs.test.d.ts.map