boperators 0.1.4 → 0.2.0

package/README.md

@@ -11,7 +11,13 @@ Operator overloading is a common programming feature that JavaScript lacks. Just
 
 `boperators` finally brings operator overloading to JavaScript by leveraging TypeScript typings. You define one or more overload functions on a class for whichever operators you want, and with magic we search for anywhere you've used overloaded operators and substitute in your functions.
 
-This is the core library and API, and isn't designed to be used directly. Instead, you can use the [Boperators CLI](https://www.npmjs.com/package/@boperators/cli) or our plugins for [compiling with `tsc`](https://www.npmjs.com/package/@boperators/plugin-tsc) or for [running directly with Bun](https://www.npmjs.com/package/@boperators/plugin-bun).
+This is the core library and API, and isn't designed to be used directly. Instead, you can use:
+- The [Boperators CLI](https://www.npmjs.com/package/@boperators/cli);
+- The [`tsc`](https://www.npmjs.com/package/@boperators/plugin-tsc) plugin;
+- The [webpack loader](https://www.npmjs.com/package/@boperators/webpack-loader);
+- The [Vite plugin](https://www.npmjs.com/package/@boperators/plugin-vite);
+- The [ESBuild plugin](https://www.npmjs.com/package/@boperators/plugin-esbuild);
+- The [Bun plugin](https://www.npmjs.com/package/@boperators/plugin-bun) for running directly with Bun.
 
 We also offer a [TypeScript Language Server plugin](https://www.npmjs.com/package/@boperators/plugin-ts-language-server) for real-time type hinting and intellisense in your IDE, and an [MCP server](https://www.npmjs.com/package/@boperators/mcp-server) to optimize your vibe coding experience.
 

package/dist/{esm/core → core}/OverloadInjector.d.ts

@@ -1,14 +1,14 @@
 import { SourceFile, type Project as TsMorphProject } from "ts-morph";
 import type { BopLogger } from "./BopConfig";
 import type { OverloadStore } from "./OverloadStore";
-import { SourceMap } from "./SourceMap";
+import { type EditRecord } from "./SourceMap";
 export type TransformResult = {
     /** The mutated ts-morph SourceFile (same reference as input). */
     sourceFile: SourceFile;
     /** The full text after transformation. */
     text: string;
-    /** Bidirectional source map between original and transformed text. */
-    sourceMap: SourceMap;
+    /** Edit records mapping positions between original and transformed text. */
+    edits: readonly EditRecord[];
 };
 export declare class OverloadInjector {
     /**

package/dist/core/OverloadInjector.js

@@ -0,0 +1,154 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverloadInjector = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const ts_morph_1 = require("ts-morph");
+const ensureImportedName_1 = require("./helpers/ensureImportedName");
+const getModuleSpecifier_1 = require("./helpers/getModuleSpecifier");
+const resolveExpressionType_1 = require("./helpers/resolveExpressionType");
+const operatorMap_1 = require("./operatorMap");
+const SourceMap_1 = require("./SourceMap");
+class OverloadInjector {
+    constructor(
+    /**
+     * TS Morph project.
+     */
+    _project, 
+    /**
+     * Overload store.
+     */
+    _overloadStore, logger) {
+        this._project = _project;
+        this._overloadStore = _overloadStore;
+        this._logger = logger;
+    }
+    overloadFile(file) {
+        const sourceFile = file instanceof ts_morph_1.SourceFile
+            ? file
+            : this._project.getSourceFileOrThrow(file);
+        const fileName = node_path_1.default.basename(sourceFile.getFilePath());
+        const originalText = sourceFile.getFullText();
+        let transformCount = 0;
+        // Outer loop: re-run all three passes until the file is fully stable.
+        // This is necessary because transforming a unary expression can unblock
+        // a binary expression (e.g. in `-v1 + v2`, the unary `-` must be
+        // replaced first so TypeScript can resolve its return type; the binary
+        // `+` overload then becomes matchable on the next outer iteration).
+        let outerChanged = true;
+        while (outerChanged) {
+            outerChanged = false;
+            // ── Binary expressions ────────────────────────────────────────────
+            // Process one innermost expression per inner iteration, re-fetching
+            // descendants each time so types resolve correctly after each
+            // transformation and AST references stay fresh.
+            let changed = true;
+            while (changed) {
+                changed = false;
+                const binaryExpressions = sourceFile
+                    .getDescendantsOfKind(ts_morph_1.SyntaxKind.BinaryExpression)
+                    .reverse();
+                for (const expression of binaryExpressions) {
+                    const operatorKind = expression.getOperatorToken().getKind();
+                    if (!(0, operatorMap_1.isOperatorSyntaxKind)(operatorKind))
+                        continue;
+                    const lhs = expression.getLeft();
+                    const leftType = (0, resolveExpressionType_1.resolveExpressionType)(lhs);
+                    const rhs = expression.getRight();
+                    const rightType = (0, resolveExpressionType_1.resolveExpressionType)(rhs);
+                    const overloadDesc = this._overloadStore.findOverload(operatorKind, leftType, rightType);
+                    if (!overloadDesc)
+                        continue;
+                    const { className: classNameRaw, classFilePath, operatorString, index, isStatic, } = overloadDesc;
+                    // Look up the fresh ClassDeclaration from the project
+                    const classSourceFile = this._project.getSourceFileOrThrow(classFilePath);
+                    const classDecl = classSourceFile.getClassOrThrow(classNameRaw);
+                    // Ensure class is imported, get its textual name
+                    const classSymbol = classDecl.getSymbol();
+                    if (!classSymbol)
+                        throw new Error(`No symbol for class "${classNameRaw}"`);
+                    const classModuleSpecifier = (0, getModuleSpecifier_1.getModuleSpecifier)(sourceFile, classSourceFile);
+                    const className = (0, ensureImportedName_1.ensureImportedName)(sourceFile, classSymbol, classModuleSpecifier);
+                    // Build the text code to replace the binary operator with the overload call
+                    const overloadCall = isStatic
+                        ? `${className}["${operatorString}"][${index}](${lhs.getText()}, ${rhs.getText()})`
+                        : `${lhs.getText()}["${operatorString}"][${index}].call(${lhs.getText()}, ${rhs.getText()})`;
+                    this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
+                    expression.replaceWithText(overloadCall);
+                    transformCount++;
+                    changed = true;
+                    outerChanged = true;
+                    break; // re-fetch descendants after each mutation
+                }
+            }
+            // ── Prefix unary expressions (-x, +x, !x, ~x) ───────────────────
+            changed = true;
+            while (changed) {
+                changed = false;
+                const prefixExpressions = sourceFile
+                    .getDescendantsOfKind(ts_morph_1.SyntaxKind.PrefixUnaryExpression)
+                    .reverse();
+                for (const expression of prefixExpressions) {
+                    const operatorKind = expression.getOperatorToken();
+                    if (!(0, operatorMap_1.isPrefixUnaryOperatorSyntaxKind)(operatorKind))
+                        continue;
+                    const operand = expression.getOperand();
+                    const operandType = (0, resolveExpressionType_1.resolveExpressionType)(operand);
+                    const overloadDesc = this._overloadStore.findPrefixUnaryOverload(operatorKind, operandType);
+                    if (!overloadDesc)
+                        continue;
+                    const { className: classNameRaw, classFilePath, operatorString, index, } = overloadDesc;
+                    const classSourceFile = this._project.getSourceFileOrThrow(classFilePath);
+                    const classDecl = classSourceFile.getClassOrThrow(classNameRaw);
+                    const classSymbol = classDecl.getSymbol();
+                    if (!classSymbol)
+                        throw new Error(`No symbol for class "${classNameRaw}"`);
+                    const classModuleSpecifier = (0, getModuleSpecifier_1.getModuleSpecifier)(sourceFile, classSourceFile);
+                    const className = (0, ensureImportedName_1.ensureImportedName)(sourceFile, classSymbol, classModuleSpecifier);
+                    const overloadCall = `${className}["${operatorString}"][${index}](${operand.getText()})`;
+                    this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
+                    expression.replaceWithText(overloadCall);
+                    transformCount++;
+                    changed = true;
+                    outerChanged = true;
+                    break;
+                }
+            }
+            // ── Postfix unary expressions (x++, x--) ─────────────────────────
+            changed = true;
+            while (changed) {
+                changed = false;
+                const postfixExpressions = sourceFile
+                    .getDescendantsOfKind(ts_morph_1.SyntaxKind.PostfixUnaryExpression)
+                    .reverse();
+                for (const expression of postfixExpressions) {
+                    const operatorKind = expression.getOperatorToken();
+                    if (!(0, operatorMap_1.isPostfixUnaryOperatorSyntaxKind)(operatorKind))
+                        continue;
+                    const operand = expression.getOperand();
+                    const operandType = (0, resolveExpressionType_1.resolveExpressionType)(operand);
+                    const overloadDesc = this._overloadStore.findPostfixUnaryOverload(operatorKind, operandType);
+                    if (!overloadDesc)
+                        continue;
+                    const { operatorString, index } = overloadDesc;
+                    const overloadCall = `${operand.getText()}["${operatorString}"][${index}].call(${operand.getText()})`;
+                    this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
+                    expression.replaceWithText(overloadCall);
+                    transformCount++;
+                    changed = true;
+                    outerChanged = true;
+                    break;
+                }
+            }
+        }
+        if (transformCount > 0) {
+            this._logger.debug(`${fileName}: ${transformCount} expression${transformCount === 1 ? "" : "s"} transformed`);
+        }
+        const text = sourceFile.getFullText();
+        const edits = (0, SourceMap_1.computeEdits)(originalText, text);
+        return { sourceFile, text, edits };
+    }
+}
+exports.OverloadInjector = OverloadInjector;

package/dist/core/SourceMap.d.ts

@@ -0,0 +1,20 @@
+export type EditRecord = {
+    /** Start position in the original source */
+    origStart: number;
+    /** End position (exclusive) in the original source */
+    origEnd: number;
+    /** Start position in the transformed source */
+    transStart: number;
+    /** End position (exclusive) in the transformed source */
+    transEnd: number;
+};
+/**
+ * Compute edit records by scanning both texts for mismatches.
+ * @public
+ *
+ * Uses character-level comparison with anchor-based convergence:
+ * identical characters are skipped, mismatches start an edit region,
+ * and convergence is found by searching for a matching anchor substring
+ * in the remaining text.
+ */
+export declare function computeEdits(original: string, transformed: string): EditRecord[];

package/dist/{cjs/core → core}/SourceMap.js

@@ -1,85 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SourceMap = void 0;
-/**
- * Bidirectional position mapping between original and transformed source text.
- *
- * Computes a list of edit records by diffing the two texts, then provides
- * O(edits) position and span mapping in both directions.
- */
-class SourceMap {
-    constructor(original, transformed) {
-        this.edits = computeEdits(original, transformed);
-    }
-    /** Returns true if no edits were detected (original === transformed). */
-    get isEmpty() {
-        return this.edits.length === 0;
-    }
-    /** Map a position from original source to transformed source. */
-    originalToTransformed(pos) {
-        let delta = 0;
-        for (const edit of this.edits) {
-            if (pos < edit.origStart) {
-                // Before this edit — just apply accumulated delta
-                break;
-            }
-            if (pos < edit.origEnd) {
-                // Inside an edited region — map to start of the transformed replacement
-                return edit.transStart;
-            }
-            // Past this edit — accumulate the delta
-            delta = edit.transEnd - edit.origEnd;
-        }
-        return pos + delta;
-    }
-    /** Map a position from transformed source to original source. */
-    transformedToOriginal(pos) {
-        let delta = 0;
-        for (const edit of this.edits) {
-            if (pos < edit.transStart) {
-                break;
-            }
-            if (pos < edit.transEnd) {
-                // Inside a transformed region — map to start of the original span
-                return edit.origStart;
-            }
-            delta = edit.origEnd - edit.transEnd;
-        }
-        return pos + delta;
-    }
-    /** Map a text span { start, length } from transformed positions to original positions. */
-    remapSpan(span) {
-        const origStart = this.transformedToOriginal(span.start);
-        const origEnd = this.transformedToOriginal(span.start + span.length);
-        return { start: origStart, length: origEnd - origStart };
-    }
-    /** Check if an original-source position falls inside an edited region. */
-    isInsideEdit(originalPos) {
-        for (const edit of this.edits) {
-            if (originalPos < edit.origStart)
-                return false;
-            if (originalPos < edit.origEnd)
-                return true;
-        }
-        return false;
-    }
-    /**
-     * For a position inside an edited region (in original coords),
-     * return the EditRecord it falls in, or undefined.
-     */
-    getEditAt(originalPos) {
-        for (const edit of this.edits) {
-            if (originalPos < edit.origStart)
-                return undefined;
-            if (originalPos < edit.origEnd)
-                return edit;
-        }
-        return undefined;
-    }
-}
-exports.SourceMap = SourceMap;
+exports.computeEdits = computeEdits;
 /**
  * Compute edit records by scanning both texts for mismatches.
+ * @public
  *
  * Uses character-level comparison with anchor-based convergence:
  * identical characters are skipped, mismatches start an edit region,

package/dist/core/v3SourceMap.d.ts

@@ -0,0 +1,21 @@
+import type { EditRecord } from "./SourceMap";
+/**
+ * Standard V3 source map object.
+ * @see https://sourcemaps.info/spec.html
+ */
+export interface V3SourceMap {
+    version: 3;
+    sources: string[];
+    names: string[];
+    sourceRoot?: string;
+    sourcesContent?: string[];
+    mappings: string;
+    file: string;
+}
+/**
+ * Convert boperators EditRecord[] into a V3 source map.
+ *
+ * Generates line-level mappings: unchanged regions map 1:1, and edit
+ * boundaries map back to the start of the original edit region.
+ */
+export declare function toV3SourceMap(edits: readonly EditRecord[], originalText: string, transformedText: string, fileName: string): V3SourceMap;

package/dist/core/v3SourceMap.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toV3SourceMap = toV3SourceMap;
+/**
+ * Convert boperators EditRecord[] into a V3 source map.
+ *
+ * Generates line-level mappings: unchanged regions map 1:1, and edit
+ * boundaries map back to the start of the original edit region.
+ */
+function toV3SourceMap(edits, originalText, transformedText, fileName) {
+    const origLineStarts = buildLineStarts(originalText);
+    const transLineStarts = buildLineStarts(transformedText);
+    // Each segment is [transCol, sourceIndex, origLine, origCol]
+    // We only have one source (index 0), so sourceIndex is always 0.
+    const mappingLines = [];
+    const transLineCount = transLineStarts.length;
+    // Initialise empty lines
+    for (let i = 0; i < transLineCount; i++) {
+        mappingLines.push([]);
+    }
+    // For positions outside any edit, the mapping is identity + accumulated delta.
+    // For positions inside an edit's transformed region, map to the original edit start.
+    // We generate one segment per transformed line start.
+    for (let transLine = 0; transLine < transLineCount; transLine++) {
+        const transOffset = transLineStarts[transLine];
+        const origOffset = transformedToOriginal(edits, transOffset);
+        const { line: origLine, col: origCol } = offsetToLineCol(origLineStarts, origOffset);
+        mappingLines[transLine].push([0, 0, origLine, origCol]);
+    }
+    return {
+        version: 3,
+        file: fileName,
+        sources: [fileName],
+        sourcesContent: [originalText],
+        names: [],
+        mappings: encodeMappings(mappingLines),
+    };
+}
+/** Map a transformed-source offset back to the original source. */
+function transformedToOriginal(edits, pos) {
+    let delta = 0;
+    for (const edit of edits) {
+        if (pos < edit.transStart) {
+            break;
+        }
+        if (pos < edit.transEnd) {
+            return edit.origStart;
+        }
+        delta = edit.origEnd - edit.transEnd;
+    }
+    return pos + delta;
+}
+/** Build an array where index i is the character offset of line i. */
+function buildLineStarts(text) {
+    const starts = [0];
+    for (let i = 0; i < text.length; i++) {
+        if (text[i] === "\n") {
+            starts.push(i + 1);
+        }
+    }
+    return starts;
+}
+/** Convert a character offset to 0-based line and column. */
+function offsetToLineCol(lineStarts, offset) {
+    // Binary search for the line containing this offset
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >>> 1;
+        if (lineStarts[mid] <= offset) {
+            lo = mid;
+        }
+        else {
+            hi = mid - 1;
+        }
+    }
+    return { line: lo, col: offset - lineStarts[lo] };
+}
+/** Encode segment arrays into a VLQ mappings string. */
+function encodeMappings(lines) {
+    let prevTransCol = 0;
+    let prevOrigLine = 0;
+    let prevOrigCol = 0;
+    let prevSourceIdx = 0;
+    const lineStrings = [];
+    for (const segments of lines) {
+        prevTransCol = 0; // reset column tracking per line
+        const segStrings = [];
+        for (const seg of segments) {
+            const [transCol, sourceIdx, origLine, origCol] = seg;
+            segStrings.push(encodeVLQ(transCol - prevTransCol) +
+                encodeVLQ(sourceIdx - prevSourceIdx) +
+                encodeVLQ(origLine - prevOrigLine) +
+                encodeVLQ(origCol - prevOrigCol));
+            prevTransCol = transCol;
+            prevSourceIdx = sourceIdx;
+            prevOrigLine = origLine;
+            prevOrigCol = origCol;
+        }
+        lineStrings.push(segStrings.join(","));
+    }
+    return lineStrings.join(";");
+}
+const VLQ_BASE = 32;
+const VLQ_BASE_MASK = VLQ_BASE - 1;
+const VLQ_CONTINUATION = VLQ_BASE;
+const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/** Encode a single integer as a VLQ base64 string. */
+function encodeVLQ(value) {
+    let vlq = value < 0 ? (-value << 1) | 1 : value << 1;
+    let result = "";
+    do {
+        let digit = vlq & VLQ_BASE_MASK;
+        vlq >>>= 5;
+        if (vlq > 0) {
+            digit |= VLQ_CONTINUATION;
+        }
+        result += BASE64_CHARS[digit];
+    } while (vlq > 0);
+    return result;
+}

package/dist/{esm/index.d.ts → index.d.ts}

@@ -11,7 +11,9 @@ export { OverloadStore } from "./core/OverloadStore";
 export type { OperatorSyntaxKind, PostfixUnaryOperatorSyntaxKind, PrefixUnaryOperatorSyntaxKind, } from "./core/operatorMap";
 export { isOperatorSyntaxKind, isPostfixUnaryOperatorSyntaxKind, isPrefixUnaryOperatorSyntaxKind, } from "./core/operatorMap";
 export type { EditRecord } from "./core/SourceMap";
-export { SourceMap } from "./core/SourceMap";
+export { computeEdits } from "./core/SourceMap";
+export type { V3SourceMap } from "./core/v3SourceMap";
+export { toV3SourceMap } from "./core/v3SourceMap";
 export type { ExportViolation, ExportViolationReason, ValidateExportsResult, } from "./core/validateExports";
 export { validateExports } from "./core/validateExports";
 export { Operator, operatorSymbols } from "./lib/operatorSymbols";

package/dist/{cjs/index.js → index.js}

@@ -1,7 +1,7 @@
 "use strict";
 // Core transformation pipeline
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyntaxKind = exports.Project = exports.Node = exports.operatorSymbols = exports.Operator = exports.validateExports = exports.SourceMap = exports.isPrefixUnaryOperatorSyntaxKind = exports.isPostfixUnaryOperatorSyntaxKind = exports.isOperatorSyntaxKind = exports.OverloadStore = exports.OverloadInjector = exports.unwrapInitializer = exports.resolveExpressionType = exports.getOperatorStringFromProperty = exports.ErrorManager = exports.ErrorDescription = exports.loadConfig = exports.ConsoleLogger = void 0;
+exports.SyntaxKind = exports.Project = exports.Node = exports.operatorSymbols = exports.Operator = exports.validateExports = exports.toV3SourceMap = exports.computeEdits = exports.isPrefixUnaryOperatorSyntaxKind = exports.isPostfixUnaryOperatorSyntaxKind = exports.isOperatorSyntaxKind = exports.OverloadStore = exports.OverloadInjector = exports.unwrapInitializer = exports.resolveExpressionType = exports.getOperatorStringFromProperty = exports.ErrorManager = exports.ErrorDescription = exports.loadConfig = exports.ConsoleLogger = void 0;
 var BopConfig_1 = require("./core/BopConfig");
 Object.defineProperty(exports, "ConsoleLogger", { enumerable: true, get: function () { return BopConfig_1.ConsoleLogger; } });
 Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return BopConfig_1.loadConfig; } });
@@ -23,7 +23,9 @@ Object.defineProperty(exports, "isOperatorSyntaxKind", { enumerable: true, get:
 Object.defineProperty(exports, "isPostfixUnaryOperatorSyntaxKind", { enumerable: true, get: function () { return operatorMap_1.isPostfixUnaryOperatorSyntaxKind; } });
 Object.defineProperty(exports, "isPrefixUnaryOperatorSyntaxKind", { enumerable: true, get: function () { return operatorMap_1.isPrefixUnaryOperatorSyntaxKind; } });
 var SourceMap_1 = require("./core/SourceMap");
-Object.defineProperty(exports, "SourceMap", { enumerable: true, get: function () { return SourceMap_1.SourceMap; } });
+Object.defineProperty(exports, "computeEdits", { enumerable: true, get: function () { return SourceMap_1.computeEdits; } });
+var v3SourceMap_1 = require("./core/v3SourceMap");
+Object.defineProperty(exports, "toV3SourceMap", { enumerable: true, get: function () { return v3SourceMap_1.toV3SourceMap; } });
 var validateExports_1 = require("./core/validateExports");
 Object.defineProperty(exports, "validateExports", { enumerable: true, get: function () { return validateExports_1.validateExports; } });
 // Operator definitions

package/package.json

@@ -1,22 +1,23 @@
 {
 	"name": "boperators",
-	"version": "0.1.4",
+	"version": "0.2.0",
 	"license": "MIT",
 	"description": "Operator overloading for TypeScript.",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/DiefBell/boperators",
+		"url": "git+https://github.com/DiefBell/boperators.git",
 		"directory": "package"
 	},
+	"bugs": {
+		"url": "https://github.com/DiefBell/boperators/issues"
+	},
 	"homepage": "https://github.com/DiefBell/boperators/tree/main/package",
-	"main": "./dist/cjs/index.js",
-	"module": "./dist/esm/index.js",
-	"types": "./dist/esm/index.d.ts",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
-			"types": "./dist/esm/index.d.ts",
-			"require": "./dist/cjs/index.js",
-			"import": "./dist/esm/index.js"
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
 		}
 	},
 	"keywords": [
@@ -30,8 +31,10 @@
 		"transform"
 	],
 	"scripts": {
-		"build": "tsc -p tsconfig.cjs.json && tsc -p tsconfig.esm.json",
-		"watch": "concurrently \"tsc -p tsconfig.cjs.json -w\" \"tsc -p tsconfig.esm.json -w\"",
+		"build": "tsc",
+		"watch": "tsc -w",
+		"test": "bun test",
+		"test:watch": "bun test --watch",
 		"prepare": "bun run build",
 		"prepublish": "bun run build"
 	},
@@ -49,7 +52,6 @@
 		"logo.png"
 	],
 	"devDependencies": {
-		"@types/node": "^22.0.0",
-		"concurrently": "^9.2.1"
+		"@types/node": "^22.0.0"
 	}
 }

package/dist/cjs/core/OverloadInjector.js

@@ -1,136 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OverloadInjector = void 0;
-const node_path_1 = __importDefault(require("node:path"));
-const ts_morph_1 = require("ts-morph");
-const ensureImportedName_1 = require("./helpers/ensureImportedName");
-const getModuleSpecifier_1 = require("./helpers/getModuleSpecifier");
-const resolveExpressionType_1 = require("./helpers/resolveExpressionType");
-const operatorMap_1 = require("./operatorMap");
-const SourceMap_1 = require("./SourceMap");
-class OverloadInjector {
-    constructor(
-    /**
-     * TS Morph project.
-     */
-    _project, 
-    /**
-     * Overload store.
-     */
-    _overloadStore, logger) {
-        this._project = _project;
-        this._overloadStore = _overloadStore;
-        this._logger = logger;
-    }
-    overloadFile(file) {
-        const sourceFile = file instanceof ts_morph_1.SourceFile
-            ? file
-            : this._project.getSourceFileOrThrow(file);
-        const fileName = node_path_1.default.basename(sourceFile.getFilePath());
-        const originalText = sourceFile.getFullText();
-        let transformCount = 0;
-        // Process one innermost binary expression per iteration,
-        // re-fetching descendants each time so types resolve correctly
-        // after each transformation and AST references stay fresh.
-        let changed = true;
-        while (changed) {
-            changed = false;
-            // Reverse DFS pre-order → innermost expressions first
-            const binaryExpressions = sourceFile
-                .getDescendantsOfKind(ts_morph_1.SyntaxKind.BinaryExpression)
-                .reverse();
-            for (const expression of binaryExpressions) {
-                const operatorKind = expression.getOperatorToken().getKind();
-                if (!(0, operatorMap_1.isOperatorSyntaxKind)(operatorKind))
-                    continue;
-                const lhs = expression.getLeft();
-                const leftType = (0, resolveExpressionType_1.resolveExpressionType)(lhs);
-                const rhs = expression.getRight();
-                const rightType = (0, resolveExpressionType_1.resolveExpressionType)(rhs);
-                const overloadDesc = this._overloadStore.findOverload(operatorKind, leftType, rightType);
-                if (!overloadDesc)
-                    continue;
-                const { className: classNameRaw, classFilePath, operatorString, index, isStatic, } = overloadDesc;
-                // Look up the fresh ClassDeclaration from the project
-                const classSourceFile = this._project.getSourceFileOrThrow(classFilePath);
-                const classDecl = classSourceFile.getClassOrThrow(classNameRaw);
-                // Ensure class is imported, get its textual name
-                const classModuleSpecifier = (0, getModuleSpecifier_1.getModuleSpecifier)(sourceFile, classSourceFile);
-                const className = (0, ensureImportedName_1.ensureImportedName)(sourceFile, classDecl.getSymbol(), classModuleSpecifier);
-                // Build the text code to replace the binary operator with the overload call
-                const overloadCall = isStatic
-                    ? `${className}["${operatorString}"][${index}](${lhs.getText()}, ${rhs.getText()})`
-                    : `${lhs.getText()}["${operatorString}"][${index}].call(${lhs.getText()}, ${rhs.getText()})`;
-                this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
-                expression.replaceWithText(overloadCall);
-                transformCount++;
-                changed = true;
-                break; // re-fetch descendants after each mutation
-            }
-        }
-        // Process prefix unary expressions (-x, +x, !x, ~x)
-        changed = true;
-        while (changed) {
-            changed = false;
-            const prefixExpressions = sourceFile
-                .getDescendantsOfKind(ts_morph_1.SyntaxKind.PrefixUnaryExpression)
-                .reverse();
-            for (const expression of prefixExpressions) {
-                const operatorKind = expression.getOperatorToken();
-                if (!(0, operatorMap_1.isPrefixUnaryOperatorSyntaxKind)(operatorKind))
-                    continue;
-                const operand = expression.getOperand();
-                const operandType = (0, resolveExpressionType_1.resolveExpressionType)(operand);
-                const overloadDesc = this._overloadStore.findPrefixUnaryOverload(operatorKind, operandType);
-                if (!overloadDesc)
-                    continue;
-                const { className: classNameRaw, classFilePath, operatorString, index, } = overloadDesc;
-                const classSourceFile = this._project.getSourceFileOrThrow(classFilePath);
-                const classDecl = classSourceFile.getClassOrThrow(classNameRaw);
-                const classModuleSpecifier = (0, getModuleSpecifier_1.getModuleSpecifier)(sourceFile, classSourceFile);
-                const className = (0, ensureImportedName_1.ensureImportedName)(sourceFile, classDecl.getSymbol(), classModuleSpecifier);
-                const overloadCall = `${className}["${operatorString}"][${index}](${operand.getText()})`;
-                this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
-                expression.replaceWithText(overloadCall);
-                transformCount++;
-                changed = true;
-                break;
-            }
-        }
-        // Process postfix unary expressions (x++, x--)
-        changed = true;
-        while (changed) {
-            changed = false;
-            const postfixExpressions = sourceFile
-                .getDescendantsOfKind(ts_morph_1.SyntaxKind.PostfixUnaryExpression)
-                .reverse();
-            for (const expression of postfixExpressions) {
-                const operatorKind = expression.getOperatorToken();
-                if (!(0, operatorMap_1.isPostfixUnaryOperatorSyntaxKind)(operatorKind))
-                    continue;
-                const operand = expression.getOperand();
-                const operandType = (0, resolveExpressionType_1.resolveExpressionType)(operand);
-                const overloadDesc = this._overloadStore.findPostfixUnaryOverload(operatorKind, operandType);
-                if (!overloadDesc)
-                    continue;
-                const { operatorString, index } = overloadDesc;
-                const overloadCall = `${operand.getText()}["${operatorString}"][${index}].call(${operand.getText()})`;
-                this._logger.debug(`${fileName}: ${expression.getText()} => ${overloadCall}`);
-                expression.replaceWithText(overloadCall);
-                transformCount++;
-                changed = true;
-                break;
-            }
-        }
-        if (transformCount > 0) {
-            this._logger.debug(`${fileName}: ${transformCount} expression${transformCount === 1 ? "" : "s"} transformed`);
-        }
-        const text = sourceFile.getFullText();
-        const sourceMap = new SourceMap_1.SourceMap(originalText, text);
-        return { sourceFile, text, sourceMap };
-    }
-}
-exports.OverloadInjector = OverloadInjector;