@mutineerjs/mutineer 0.2.4 → 0.4.0

package/README.md

@@ -26,25 +26,31 @@ Mutations are applied using Babel AST analysis, so operators inside strings and
 
 ## Supported Mutations (WIP)
 
-| Category   | Mutator         | Transformation     |
-| ---------- | --------------- | ------------------ |
-| Equality   | `flipStrictEQ`  | `===` → `!==` |
-|            | `flipStrictNEQ` | `!==` → `===` |
-|            | `flipEQ`        | `==` → `!=`   |
-|            | `flipNEQ`       | `!=` → `==`   |
-| Boundary   | `relaxLE`       | `<=` &rarr; `<`    |
-|            | `relaxGE`       | `>=` &rarr; `>`    |
-|            | `tightenLT`     | `<` &rarr; `<=`    |
-|            | `tightenGT`     | `>` &rarr; `>=`    |
-| Logical    | `andToOr`       | `&&` &rarr; `\|\|` |
-|            | `orToAnd`       | `\|\|` &rarr; `&&` |
-|            | `nullishToOr`   | `??` &rarr; `\|\|` |
-| Arithmetic | `addToSub`      | `+` &rarr; `-`     |
-|            | `subToAdd`      | `-` &rarr; `+`     |
-|            | `mulToDiv`      | `*` &rarr; `/`     |
-|            | `divToMul`      | `/` &rarr; `*`     |
-|            | `modToMul`      | `%` &rarr; `*`     |
-|            | `powerToMul`    | `**` &rarr; `*`    |
+| Category     | Mutator             | Transformation                       |
+| ------------ | ------------------- | ------------------------------------ |
+| Equality     | `flipStrictEQ`      | `===` &rarr; `!==`                   |
+|              | `flipStrictNEQ`     | `!==` &rarr; `===`                   |
+|              | `flipEQ`            | `==` &rarr; `!=`                     |
+|              | `flipNEQ`           | `!=` &rarr; `==`                     |
+| Boundary     | `relaxLE`           | `<=` &rarr; `<`                      |
+|              | `relaxGE`           | `>=` &rarr; `>`                      |
+|              | `tightenLT`         | `<` &rarr; `<=`                      |
+|              | `tightenGT`         | `>` &rarr; `>=`                      |
+| Logical      | `andToOr`           | `&&` &rarr; `\|\|`                   |
+|              | `orToAnd`           | `\|\|` &rarr; `&&`                   |
+|              | `nullishToOr`       | `??` &rarr; `\|\|`                   |
+| Arithmetic   | `addToSub`          | `+` &rarr; `-`                       |
+|              | `subToAdd`          | `-` &rarr; `+`                       |
+|              | `mulToDiv`          | `*` &rarr; `/`                       |
+|              | `divToMul`          | `/` &rarr; `*`                       |
+|              | `modToMul`          | `%` &rarr; `*`                       |
+|              | `powerToMul`        | `**` &rarr; `*`                      |
+| Return value | `returnToNull`      | `return x` &rarr; `return null`      |
+|              | `returnToUndefined` | `return x` &rarr; `return undefined` |
+|              | `returnFlipBool`    | `return true` &harr; `return false`  |
+|              | `returnZero`        | `return n` &rarr; `return 0`         |
+|              | `returnEmptyStr`    | `return s` &rarr; `return ''`        |
+|              | `returnEmptyArr`    | `return [...]` &rarr; `return []`    |
 
 ## Installation
 
@@ -56,11 +62,11 @@ npm i @mutineerjs/mutineer
 
 ### Commands
 
-| Command          | Description                                          |
-| ---------------- | ---------------------------------------------------- |
-| `mutineer init`  | Create a `mutineer.config.ts` with minimal defaults  |
-| `mutineer run`   | Run mutation testing                                 |
-| `mutineer clean` | Remove leftover `__mutineer__` temp directories      |
+| Command          | Description                                         |
+| ---------------- | --------------------------------------------------- |
+| `mutineer init`  | Create a `mutineer.config.ts` with minimal defaults |
+| `mutineer run`   | Run mutation testing                                |
+| `mutineer clean` | Remove leftover `__mutineer__` temp directories     |
 
 ### Quick Start
 
@@ -93,7 +99,7 @@ npm run mutineer
 | ------------------------ | ------------------------------------------ | ------------- |
 | `--runner <type>`        | Test runner: `vitest` or `jest`            | `vitest`      |
 | `--config`, `-c`         | Path to config file                        | auto-detected |
-| `--concurrency <n>`      | Parallel workers (1-4)                     | CPUs - 1      |
+| `--concurrency <n>`      | Parallel workers (min 1)                   | CPUs - 1      |
 | `--changed`              | Only mutate files changed vs base branch   | --            |
 | `--changed-with-deps`    | Include dependents of changed files        | --            |
 | `--only-covered-lines`   | Skip mutations on uncovered lines          | --            |
@@ -140,23 +146,23 @@ export default defineMutineerConfig({
 
 ### Config Options
 
-| Option              | Type                               | Description                                      |
-| ------------------- | ---------------------------------- | ------------------------------------------------ |
-| `source`            | `string \| string[]`               | Glob patterns for source files to mutate         |
-| `targets`           | `MutateTarget[]`                   | Explicit list of files to mutate                 |
-| `runner`            | `'vitest' \| 'jest'`               | Test runner to use                               |
-| `vitestConfig`      | `string`                           | Path to vitest config                            |
-| `jestConfig`        | `string`                           | Path to jest config                              |
-| `include`           | `string[]`                         | Only run these mutators                          |
-| `exclude`           | `string[]`                         | Skip these mutators                              |
-| `excludePaths`      | `string[]`                         | Glob patterns for paths to skip                  |
-| `maxMutantsPerFile` | `number`                           | Cap mutations per file                           |
-| `minKillPercent`    | `number`                           | Fail if kill rate is below this                  |
-| `onlyCoveredLines`  | `boolean`                          | Only mutate lines covered by tests               |
-| `perTestCoverage`   | `boolean`                          | Use per-test coverage to select tests            |
-| `baseRef`           | `string`                           | Git ref for `--changed` (default: `origin/main`) |
-| `testPatterns`      | `string[]`                         | Globs for test file discovery                    |
-| `extensions`        | `string[]`                         | File extensions to consider                      |
+| Option              | Type                 | Description                                      |
+| ------------------- | -------------------- | ------------------------------------------------ |
+| `source`            | `string \| string[]` | Glob patterns for source files to mutate         |
+| `targets`           | `MutateTarget[]`     | Explicit list of files to mutate                 |
+| `runner`            | `'vitest' \| 'jest'` | Test runner to use                               |
+| `vitestConfig`      | `string`             | Path to vitest config                            |
+| `jestConfig`        | `string`             | Path to jest config                              |
+| `include`           | `string[]`           | Only run these mutators                          |
+| `exclude`           | `string[]`           | Skip these mutators                              |
+| `excludePaths`      | `string[]`           | Glob patterns for paths to skip                  |
+| `maxMutantsPerFile` | `number`             | Cap mutations per file                           |
+| `minKillPercent`    | `number`             | Fail if kill rate is below this                  |
+| `onlyCoveredLines`  | `boolean`            | Only mutate lines covered by tests               |
+| `perTestCoverage`   | `boolean`            | Use per-test coverage to select tests            |
+| `baseRef`           | `string`             | Git ref for `--changed` (default: `origin/main`) |
+| `testPatterns`      | `string[]`           | Globs for test file discovery                    |
+| `extensions`        | `string[]`           | File extensions to consider                      |
 
 ## File Support
 

package/dist/mutators/__tests__/operator.spec.js

@@ -0,0 +1,169 @@
+import { describe, it, expect } from 'vitest';
+import { relaxLE, relaxGE, tightenLT, tightenGT, andToOr, orToAnd, nullishToOr, flipEQ, flipNEQ, flipStrictEQ, flipStrictNEQ, addToSub, subToAdd, mulToDiv, divToMul, modToMul, powerToMul, } from '../operator.js';
+// ---------------------------------------------------------------------------
+// Shared behaviour (tested once; all mutators use the same factory)
+// ---------------------------------------------------------------------------
+describe('operator mutator shared behaviour', () => {
+    it('produces one mutation per matching operator occurrence', () => {
+        const src = `const ok = a && b && c`;
+        const results = andToOr.apply(src);
+        expect(results).toHaveLength(2);
+    });
+    it('reports the correct 1-based line number', () => {
+        const src = `const x = 1\nconst ok = a && b`;
+        const [result] = andToOr.apply(src);
+        expect(result.line).toBe(2);
+    });
+    it('reports the correct visual column', () => {
+        const src = `const ok = a && b`;
+        //                        ^ col 14 ('a' is at col 12, ' ' 13, '&' 14)
+        const [result] = andToOr.apply(src);
+        expect(result.col).toBe(14);
+    });
+    it('does not mutate operators inside string literals (AST-safe)', () => {
+        const src = `const s = 'a && b'`;
+        const results = andToOr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate operators inside comments (AST-safe)', () => {
+        const src = `// a && b\nconst x = 1`;
+        const results = andToOr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('returns no results when the operator is absent', () => {
+        const src = `const x = a || b`;
+        const results = andToOr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// Boundary mutators
+// ---------------------------------------------------------------------------
+describe('relaxLE', () => {
+    it("replaces '<=' with '<'", () => {
+        const src = `if (x <= 10) {}`;
+        const [result] = relaxLE.apply(src);
+        expect(result.code).toBe(`if (x < 10) {}`);
+    });
+});
+describe('relaxGE', () => {
+    it("replaces '>=' with '>'", () => {
+        const src = `if (x >= 0) {}`;
+        const [result] = relaxGE.apply(src);
+        expect(result.code).toBe(`if (x > 0) {}`);
+    });
+});
+describe('tightenLT', () => {
+    it("replaces '<' with '<='", () => {
+        const src = `if (x < 10) {}`;
+        const [result] = tightenLT.apply(src);
+        expect(result.code).toBe(`if (x <= 10) {}`);
+    });
+});
+describe('tightenGT', () => {
+    it("replaces '>' with '>='", () => {
+        const src = `if (x > 0) {}`;
+        const [result] = tightenGT.apply(src);
+        expect(result.code).toBe(`if (x >= 0) {}`);
+    });
+});
+// ---------------------------------------------------------------------------
+// Logical mutators
+// ---------------------------------------------------------------------------
+describe('andToOr', () => {
+    it("replaces '&&' with '||'", () => {
+        const src = `const ok = a && b`;
+        const [result] = andToOr.apply(src);
+        expect(result.code).toBe(`const ok = a || b`);
+    });
+});
+describe('orToAnd', () => {
+    it("replaces '||' with '&&'", () => {
+        const src = `const ok = a || b`;
+        const [result] = orToAnd.apply(src);
+        expect(result.code).toBe(`const ok = a && b`);
+    });
+});
+describe('nullishToOr', () => {
+    it("replaces '??' with '||'", () => {
+        const src = `const v = x ?? defaultValue`;
+        const [result] = nullishToOr.apply(src);
+        expect(result.code).toBe(`const v = x || defaultValue`);
+    });
+});
+// ---------------------------------------------------------------------------
+// Equality mutators
+// ---------------------------------------------------------------------------
+describe('flipEQ', () => {
+    it("replaces '==' with '!='", () => {
+        const src = `if (a == b) {}`;
+        const [result] = flipEQ.apply(src);
+        expect(result.code).toBe(`if (a != b) {}`);
+    });
+});
+describe('flipNEQ', () => {
+    it("replaces '!=' with '=='", () => {
+        const src = `if (a != b) {}`;
+        const [result] = flipNEQ.apply(src);
+        expect(result.code).toBe(`if (a == b) {}`);
+    });
+});
+describe('flipStrictEQ', () => {
+    it("replaces '===' with '!=='", () => {
+        const src = `if (a === b) {}`;
+        const [result] = flipStrictEQ.apply(src);
+        expect(result.code).toBe(`if (a !== b) {}`);
+    });
+});
+describe('flipStrictNEQ', () => {
+    it("replaces '!==' with '==='", () => {
+        const src = `if (a !== b) {}`;
+        const [result] = flipStrictNEQ.apply(src);
+        expect(result.code).toBe(`if (a === b) {}`);
+    });
+});
+// ---------------------------------------------------------------------------
+// Arithmetic mutators
+// ---------------------------------------------------------------------------
+describe('addToSub', () => {
+    it("replaces '+' with '-'", () => {
+        const src = `const n = a + b`;
+        const [result] = addToSub.apply(src);
+        expect(result.code).toBe(`const n = a - b`);
+    });
+});
+describe('subToAdd', () => {
+    it("replaces '-' with '+'", () => {
+        const src = `const n = a - b`;
+        const [result] = subToAdd.apply(src);
+        expect(result.code).toBe(`const n = a + b`);
+    });
+});
+describe('mulToDiv', () => {
+    it("replaces '*' with '/'", () => {
+        const src = `const n = a * b`;
+        const [result] = mulToDiv.apply(src);
+        expect(result.code).toBe(`const n = a / b`);
+    });
+});
+describe('divToMul', () => {
+    it("replaces '/' with '*'", () => {
+        const src = `const n = a / b`;
+        const [result] = divToMul.apply(src);
+        expect(result.code).toBe(`const n = a * b`);
+    });
+});
+describe('modToMul', () => {
+    it("replaces '%' with '*'", () => {
+        const src = `const n = a % b`;
+        const [result] = modToMul.apply(src);
+        expect(result.code).toBe(`const n = a * b`);
+    });
+});
+describe('powerToMul', () => {
+    it("replaces '**' with '*'", () => {
+        const src = `const n = a ** b`;
+        const [result] = powerToMul.apply(src);
+        expect(result.code).toBe(`const n = a * b`);
+    });
+});

package/dist/mutators/__tests__/registry.spec.js

@@ -18,6 +18,12 @@ const ALL_NAMES = [
     'divToMul',
     'modToMul',
     'powerToMul',
+    'returnToNull',
+    'returnToUndefined',
+    'returnFlipBool',
+    'returnZero',
+    'returnEmptyStr',
+    'returnEmptyArr',
 ];
 describe('mutator registry', () => {
     it('returns all mutators by default in declared order', () => {

package/dist/mutators/__tests__/return-value.spec.js

@@ -0,0 +1,239 @@
+import { describe, it, expect } from 'vitest';
+import { returnToNull, returnToUndefined, returnFlipBool, returnZero, returnEmptyStr, returnEmptyArr, } from '../return-value.js';
+// ---------------------------------------------------------------------------
+// returnToNull
+// ---------------------------------------------------------------------------
+describe('returnToNull', () => {
+    it('replaces an identifier return with null', () => {
+        const src = `function f() { return x }`;
+        const [mutation] = returnToNull.apply(src);
+        expect(mutation.code).toBe(`function f() { return null }`);
+    });
+    it('replaces a function call return with null', () => {
+        const src = `function f() { return getValue() }`;
+        const [mutation] = returnToNull.apply(src);
+        expect(mutation.code).toBe(`function f() { return null }`);
+    });
+    it('replaces a numeric literal return with null', () => {
+        const src = `function f() { return 42 }`;
+        const [mutation] = returnToNull.apply(src);
+        expect(mutation.code).toBe(`function f() { return null }`);
+    });
+    it('replaces an object expression return with null', () => {
+        const src = `function f() { return { a: 1 } }`;
+        const [mutation] = returnToNull.apply(src);
+        expect(mutation.code).toBe(`function f() { return null }`);
+    });
+    it('does not mutate bare return;', () => {
+        const src = `function f() { return }`;
+        const results = returnToNull.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate return null', () => {
+        const src = `function f() { return null }`;
+        const results = returnToNull.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('produces one mutation per matching return statement', () => {
+        const src = `
+function f() {
+  if (x) return a
+  return b
+}
+`;
+        const results = returnToNull.apply(src);
+        expect(results).toHaveLength(2);
+        expect(results[0].code).toContain('return null');
+        expect(results[1].code).toContain('return null');
+    });
+    it('reports the correct line for the return statement', () => {
+        const src = `function f() {\n  return x\n}`;
+        const [mutation] = returnToNull.apply(src);
+        expect(mutation.line).toBe(2);
+    });
+    it('respects mutineer-disable-next-line', () => {
+        const src = `
+function f() {
+  // mutineer-disable-next-line
+  return x
+  return y
+}
+`;
+        const results = returnToNull.apply(src);
+        expect(results).toHaveLength(1);
+        expect(results[0].code).toContain('return null');
+    });
+    it('respects mutineer-disable-line', () => {
+        const src = `
+function f() {
+  return x // mutineer-disable-line
+  return y
+}
+`;
+        const results = returnToNull.apply(src);
+        expect(results).toHaveLength(1);
+    });
+});
+// ---------------------------------------------------------------------------
+// returnToUndefined
+// ---------------------------------------------------------------------------
+describe('returnToUndefined', () => {
+    it('replaces an identifier return with undefined', () => {
+        const src = `function f() { return x }`;
+        const [mutation] = returnToUndefined.apply(src);
+        expect(mutation.code).toBe(`function f() { return undefined }`);
+    });
+    it('replaces a function call return with undefined', () => {
+        const src = `function f() { return getValue() }`;
+        const [mutation] = returnToUndefined.apply(src);
+        expect(mutation.code).toBe(`function f() { return undefined }`);
+    });
+    it('replaces null with undefined', () => {
+        const src = `function f() { return null }`;
+        const [mutation] = returnToUndefined.apply(src);
+        expect(mutation.code).toBe(`function f() { return undefined }`);
+    });
+    it('does not mutate bare return;', () => {
+        const src = `function f() { return }`;
+        const results = returnToUndefined.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate return undefined', () => {
+        const src = `function f() { return undefined }`;
+        const results = returnToUndefined.apply(src);
+        expect(results).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// returnFlipBool
+// ---------------------------------------------------------------------------
+describe('returnFlipBool', () => {
+    it('flips return true to return false', () => {
+        const src = `function f() { return true }`;
+        const [mutation] = returnFlipBool.apply(src);
+        expect(mutation.code).toBe(`function f() { return false }`);
+    });
+    it('flips return false to return true', () => {
+        const src = `function f() { return false }`;
+        const [mutation] = returnFlipBool.apply(src);
+        expect(mutation.code).toBe(`function f() { return true }`);
+    });
+    it('does not mutate non-boolean returns', () => {
+        const src = `function f() { return x }`;
+        const results = returnFlipBool.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate bare return;', () => {
+        const src = `function f() { return }`;
+        const results = returnFlipBool.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('handles multiple boolean returns independently', () => {
+        const src = `
+function f(x) {
+  if (x) return true
+  return false
+}
+`;
+        const results = returnFlipBool.apply(src);
+        expect(results).toHaveLength(2);
+        expect(results[0].code).toContain('return false');
+        expect(results[1].code).toContain('return true');
+    });
+});
+// ---------------------------------------------------------------------------
+// returnZero
+// ---------------------------------------------------------------------------
+describe('returnZero', () => {
+    it('replaces a positive integer return with 0', () => {
+        const src = `function f() { return 42 }`;
+        const [mutation] = returnZero.apply(src);
+        expect(mutation.code).toBe(`function f() { return 0 }`);
+    });
+    it('replaces a negative number return with 0', () => {
+        const src = `function f() { return -1 }`;
+        // -1 is a UnaryExpression, not a NumericLiteral — should produce no output
+        const results = returnZero.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('replaces a float return with 0', () => {
+        const src = `function f() { return 3.14 }`;
+        const [mutation] = returnZero.apply(src);
+        expect(mutation.code).toBe(`function f() { return 0 }`);
+    });
+    it('does not mutate return 0', () => {
+        const src = `function f() { return 0 }`;
+        const results = returnZero.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate non-numeric returns', () => {
+        const src = `function f() { return x }`;
+        const results = returnZero.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate bare return;', () => {
+        const src = `function f() { return }`;
+        const results = returnZero.apply(src);
+        expect(results).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// returnEmptyStr
+// ---------------------------------------------------------------------------
+describe('returnEmptyStr', () => {
+    it("replaces a non-empty string return with ''", () => {
+        const src = `function f() { return 'hello' }`;
+        const [mutation] = returnEmptyStr.apply(src);
+        expect(mutation.code).toBe(`function f() { return '' }`);
+    });
+    it('replaces a double-quoted string return', () => {
+        const src = `function f() { return "world" }`;
+        const [mutation] = returnEmptyStr.apply(src);
+        expect(mutation.code).toBe(`function f() { return '' }`);
+    });
+    it("does not mutate return ''", () => {
+        const src = `function f() { return '' }`;
+        const results = returnEmptyStr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate non-string returns', () => {
+        const src = `function f() { return x }`;
+        const results = returnEmptyStr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate bare return;', () => {
+        const src = `function f() { return }`;
+        const results = returnEmptyStr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// returnEmptyArr
+// ---------------------------------------------------------------------------
+describe('returnEmptyArr', () => {
+    it('replaces a non-empty array return with []', () => {
+        const src = `function f() { return [1, 2, 3] }`;
+        const [mutation] = returnEmptyArr.apply(src);
+        expect(mutation.code).toBe(`function f() { return [] }`);
+    });
+    it('replaces a single-element array return with []', () => {
+        const src = `function f() { return [x] }`;
+        const [mutation] = returnEmptyArr.apply(src);
+        expect(mutation.code).toBe(`function f() { return [] }`);
+    });
+    it('does not mutate return []', () => {
+        const src = `function f() { return [] }`;
+        const results = returnEmptyArr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate non-array returns', () => {
+        const src = `function f() { return x }`;
+        const results = returnEmptyArr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+    it('does not mutate bare return;', () => {
+        const src = `function f() { return }`;
+        const results = returnEmptyArr.apply(src);
+        expect(results).toHaveLength(0);
+    });
+});

package/dist/mutators/__tests__/utils.spec.js

@@ -1,5 +1,72 @@
 import { describe, it, expect } from 'vitest';
-import { collectOperatorTargets } from '../utils.js';
+import { collectOperatorTargets, buildIgnoreLines, parseSource, } from '../utils.js';
+// ---------------------------------------------------------------------------
+// buildIgnoreLines
+// ---------------------------------------------------------------------------
+describe('buildIgnoreLines', () => {
+    function comment(text, startLine, endLine = startLine) {
+        return {
+            type: 'CommentLine',
+            value: ` ${text}`,
+            start: 0,
+            end: 0,
+            loc: {
+                start: { line: startLine, column: 0, index: 0 },
+                end: { line: endLine, column: 0, index: 0 },
+            },
+        };
+    }
+    it('ignores the line after mutineer-disable-next-line', () => {
+        // The text also contains 'mutineer-disable' as a substring, so the
+        // comment line itself is ignored in addition to the following line.
+        const lines = buildIgnoreLines([comment('mutineer-disable-next-line', 3)]);
+        expect(lines.has(4)).toBe(true);
+        expect(lines.has(3)).toBe(true);
+        expect(lines.has(5)).toBe(false);
+    });
+    it('ignores the comment line itself for mutineer-disable-line', () => {
+        const lines = buildIgnoreLines([comment('mutineer-disable-line', 5)]);
+        expect(lines.has(5)).toBe(true);
+        expect(lines.has(6)).toBe(false);
+    });
+    it('ignores all lines spanned by a mutineer-disable block comment', () => {
+        const lines = buildIgnoreLines([comment('mutineer-disable', 2, 4)]);
+        expect(lines.has(2)).toBe(true);
+        expect(lines.has(3)).toBe(true);
+        expect(lines.has(4)).toBe(true);
+        expect(lines.has(1)).toBe(false);
+        expect(lines.has(5)).toBe(false);
+    });
+    it('ignores comments without loc', () => {
+        const c = {
+            ...comment('mutineer-disable-next-line', 1),
+            loc: undefined,
+        };
+        expect(() => buildIgnoreLines([c])).not.toThrow();
+    });
+    it('returns an empty set when there are no disable comments', () => {
+        const lines = buildIgnoreLines([comment('just a normal comment', 1)]);
+        expect(lines.size).toBe(0);
+    });
+});
+// ---------------------------------------------------------------------------
+// parseSource
+// ---------------------------------------------------------------------------
+describe('parseSource', () => {
+    it('parses valid TypeScript source without throwing', () => {
+        expect(() => parseSource(`const x: number = 1`)).not.toThrow();
+    });
+    it('parses JSX without throwing', () => {
+        expect(() => parseSource(`const el = <div />`)).not.toThrow();
+    });
+    it('returns a File node', () => {
+        const ast = parseSource(`const x = 1`);
+        expect(ast.type).toBe('File');
+    });
+});
+// ---------------------------------------------------------------------------
+// collectOperatorTargets
+// ---------------------------------------------------------------------------
 describe('collectOperatorTargets', () => {
     it('honors mutineer disable comments', () => {
         const src = `// mutineer-disable-next-line

package/dist/mutators/operator.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Operator mutators.
+ *
+ * Each mutator finds every occurrence of a specific binary/logical operator
+ * using AST traversal and produces a mutated source string with that operator
+ * replaced by its counterpart.
+ */
+import type { ASTMutator } from './types.js';
+export declare const relaxLE: ASTMutator;
+export declare const relaxGE: ASTMutator;
+export declare const tightenLT: ASTMutator;
+export declare const tightenGT: ASTMutator;
+export declare const andToOr: ASTMutator;
+export declare const orToAnd: ASTMutator;
+export declare const nullishToOr: ASTMutator;
+export declare const flipEQ: ASTMutator;
+export declare const flipNEQ: ASTMutator;
+export declare const flipStrictEQ: ASTMutator;
+export declare const flipStrictNEQ: ASTMutator;
+export declare const addToSub: ASTMutator;
+export declare const subToAdd: ASTMutator;
+export declare const mulToDiv: ASTMutator;
+export declare const divToMul: ASTMutator;
+export declare const modToMul: ASTMutator;
+export declare const powerToMul: ASTMutator;