boperators 0.1.0

package/dist/cjs/core/SourceMap.js

@@ -0,0 +1,168 @@
+"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;
+/**
+ * Compute edit records by scanning both texts for mismatches.
+ *
+ * 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.
+ */
+function computeEdits(original, transformed) {
+    if (original === transformed)
+        return [];
+    const edits = [];
+    let i = 0; // index in original
+    let j = 0; // index in transformed
+    while (i < original.length && j < transformed.length) {
+        // Skip matching characters
+        if (original[i] === transformed[j]) {
+            i++;
+            j++;
+            continue;
+        }
+        // Mismatch — start of an edit
+        const origEditStart = i;
+        const transEditStart = j;
+        // Find where the texts converge again.
+        // Search for an anchor: a substring from `original` that also
+        // appears at the corresponding position in `transformed`.
+        const ANCHOR_LEN = 8;
+        let found = false;
+        // Scan ahead in original from the mismatch point
+        for (let oi = origEditStart + 1; oi <= original.length - ANCHOR_LEN; oi++) {
+            const anchor = original.substring(oi, oi + ANCHOR_LEN);
+            const transPos = transformed.indexOf(anchor, transEditStart);
+            if (transPos >= 0) {
+                // Verify the anchor actually converges by checking a few more chars
+                let valid = true;
+                const verifyLen = Math.min(ANCHOR_LEN * 2, original.length - oi, transformed.length - transPos);
+                for (let k = ANCHOR_LEN; k < verifyLen; k++) {
+                    if (original[oi + k] !== transformed[transPos + k]) {
+                        valid = false;
+                        break;
+                    }
+                }
+                if (valid) {
+                    edits.push({
+                        origStart: origEditStart,
+                        origEnd: oi,
+                        transStart: transEditStart,
+                        transEnd: transPos,
+                    });
+                    i = oi;
+                    j = transPos;
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found) {
+            // No convergence — remaining text is all part of the edit.
+            // Use common suffix to tighten the bounds.
+            let suffixLen = 0;
+            while (suffixLen < original.length - origEditStart &&
+                suffixLen < transformed.length - transEditStart &&
+                original[original.length - 1 - suffixLen] ===
+                    transformed[transformed.length - 1 - suffixLen]) {
+                suffixLen++;
+            }
+            edits.push({
+                origStart: origEditStart,
+                origEnd: original.length - suffixLen,
+                transStart: transEditStart,
+                transEnd: transformed.length - suffixLen,
+            });
+            i = original.length;
+            j = transformed.length;
+        }
+    }
+    // Handle remaining text at the end
+    if (i < original.length || j < transformed.length) {
+        edits.push({
+            origStart: i,
+            origEnd: original.length,
+            transStart: j,
+            transEnd: transformed.length,
+        });
+    }
+    return edits;
+}

package/dist/cjs/core/helpers/ensureImportedName.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureImportedName = void 0;
+const ts_morph_1 = require("ts-morph");
+const getImportedNameForSymbol_1 = require("./getImportedNameForSymbol");
+/**
+ * Ensures that the specified symbol is imported into the source file.
+ * If it is not already imported, adds it.
+ *
+ * @param sourceFile The SourceFile to modify.
+ * @param symbol The AstSymbol representing the class to import.
+ * @param moduleSpecifier The module from which the class should be imported.
+ * @returns The imported identifier name to use in the source file.
+ */
+const ensureImportedName = (sourceFile, symbol, moduleSpecifier) => {
+    // Attempt to get the imported name if it already exists
+    const existingName = (0, getImportedNameForSymbol_1.getImportedNameForSymbol)(sourceFile, symbol);
+    if (existingName)
+        return existingName; // Return the already-imported name
+    // Generate a unique name for the new import
+    const symbolName = symbol.getName();
+    let newImportName = symbolName;
+    // Ensure the name doesn't clash with existing identifiers in the source file
+    const existingIdentifiers = sourceFile.getDescendantsOfKind(ts_morph_1.SyntaxKind.Identifier);
+    const existingNames = new Set(existingIdentifiers.map((id) => id.getText()));
+    while (existingNames.has(newImportName)) {
+        newImportName = `${symbolName}_${Math.random().toString(36).substr(2, 5)}`;
+    }
+    // Check if the module is already imported
+    const existingImport = sourceFile
+        .getImportDeclarations()
+        .find((importDecl) => importDecl.getModuleSpecifierValue() === moduleSpecifier);
+    if (existingImport) {
+        // Add the new import to the named imports
+        existingImport.addNamedImport(newImportName === symbolName
+            ? symbolName
+            : { name: symbolName, alias: newImportName });
+    }
+    else {
+        // Add a new import declaration
+        sourceFile.addImportDeclaration({
+            moduleSpecifier,
+            namedImports: newImportName === symbolName
+                ? [symbolName]
+                : [{ name: symbolName, alias: newImportName }],
+        });
+    }
+    return newImportName;
+};
+exports.ensureImportedName = ensureImportedName;

package/dist/cjs/core/helpers/getImportedNameForSymbol.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImportedNameForSymbol = void 0;
+/**
+ * Checks if the given symbol is already imported in the SourceFile.
+ * @param sourceFile The SourceFile to search for imports.
+ * @param symbol The AstSymbol to match against imports.
+ * @returns The imported identifier name if found, otherwise undefined.
+ */
+const getImportedNameForSymbol = (sourceFile, symbol) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const aliasedSymbol = (_a = symbol.getAliasedSymbol()) !== null && _a !== void 0 ? _a : symbol;
+    // Helper function to compare symbols by their declarations
+    const symbolsAreEquivalent = (a, b) => {
+        if (!a || !b)
+            return false;
+        const aDecls = a.getDeclarations();
+        const bDecls = b.getDeclarations();
+        if (aDecls.length !== bDecls.length)
+            return false;
+        return aDecls.every((aDecl, i) => aDecl.getSourceFile() === bDecls[i].getSourceFile() &&
+            aDecl.getStart() === bDecls[i].getStart());
+    };
+    // Get all import declarations in the source file
+    const importDeclarations = sourceFile.getImportDeclarations();
+    for (const importDecl of importDeclarations) {
+        // Named imports
+        const namedImports = importDecl.getNamedImports();
+        for (const namedImport of namedImports) {
+            const importedSymbol = namedImport.getSymbol();
+            if (symbolsAreEquivalent(importedSymbol === null || importedSymbol === void 0 ? void 0 : importedSymbol.getAliasedSymbol(), aliasedSymbol)) {
+                return ((_c = (_b = namedImport.getAliasNode()) === null || _b === void 0 ? void 0 : _b.getText()) !== null && _c !== void 0 ? _c : namedImport.getNameNode().getText());
+            }
+        }
+        // Default import
+        const defaultImport = importDecl.getDefaultImport();
+        if (defaultImport) {
+            const defaultSymbol = (_d = defaultImport.getSymbol()) === null || _d === void 0 ? void 0 : _d.getAliasedSymbol();
+            if (symbolsAreEquivalent(defaultSymbol, aliasedSymbol)) {
+                // Return the default import name
+                return defaultImport.getText();
+            }
+        }
+        // Check namespace imports
+        const namespaceImport = importDecl.getNamespaceImport();
+        if (namespaceImport) {
+            const namespaceSymbol = namespaceImport.getSymbol();
+            if (namespaceSymbol) {
+                // Look for the symbol under this namespace
+                const exports = (_f = (_e = namespaceSymbol.getAliasedSymbol()) === null || _e === void 0 ? void 0 : _e.getExports()) !== null && _f !== void 0 ? _f : [];
+                for (const exportedSymbol of exports) {
+                    const resolvedExportedSymbol = (_g = exportedSymbol.getAliasedSymbol()) !== null && _g !== void 0 ? _g : exportedSymbol;
+                    if (symbolsAreEquivalent(resolvedExportedSymbol, aliasedSymbol)) {
+                        // Return namespace-qualified name (e.g., v3.Vector3)
+                        return `${namespaceImport.getText()}.${exportedSymbol.getName()}`;
+                    }
+                }
+            }
+        }
+    }
+    // No matching import found
+    return undefined;
+};
+exports.getImportedNameForSymbol = getImportedNameForSymbol;

package/dist/cjs/core/helpers/getModuleSpecifier.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModuleSpecifier = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/**
+ * Walk up from a file path to find the nearest `package.json` with a `name`
+ * field. Returns the package name and the directory containing it.
+ */
+function findPackageInfo(filePath) {
+    const normalized = filePath.replace(/\\/g, "/");
+    let dir = node_path_1.posix.dirname(normalized);
+    while (true) {
+        const pkgJsonPath = `${dir}/package.json`;
+        if ((0, node_fs_1.existsSync)(pkgJsonPath)) {
+            try {
+                const content = (0, node_fs_1.readFileSync)(pkgJsonPath, "utf-8");
+                const pkg = JSON.parse(content);
+                if (typeof pkg.name === "string") {
+                    return { name: pkg.name, dir };
+                }
+            }
+            catch (_a) {
+                // Malformed package.json, continue searching up
+            }
+        }
+        const parent = node_path_1.posix.dirname(dir);
+        if (parent === dir)
+            break; // filesystem root
+        dir = parent;
+    }
+    return undefined;
+}
+/**
+ * Checks if `fromFile` already imports from `pkgName` (or a subpath of it)
+ * and returns that specifier if so. Otherwise returns `pkgName` bare.
+ */
+function reuseExistingImportOrReturn(fromFile, pkgName) {
+    for (const decl of fromFile.getImportDeclarations()) {
+        const specifier = decl.getModuleSpecifierValue();
+        if (specifier === pkgName || specifier.startsWith(`${pkgName}/`)) {
+            return specifier;
+        }
+    }
+    return pkgName;
+}
+const getModuleSpecifier = (fromFile, toFile) => {
+    const toPath = toFile.getFilePath();
+    const fromPath = fromFile.getFilePath();
+    // Check if source and target belong to different packages
+    const toPkg = findPackageInfo(toPath);
+    const fromPkg = findPackageInfo(fromPath);
+    if (toPkg && fromPkg && toPkg.dir !== fromPkg.dir) {
+        return reuseExistingImportOrReturn(fromFile, toPkg.name);
+    }
+    // Same package (or couldn't determine) — use a relative path
+    const fromDir = node_path_1.posix.dirname(fromPath);
+    const relativePath = node_path_1.posix.relative(fromDir, toPath);
+    return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+};
+exports.getModuleSpecifier = getModuleSpecifier;

package/dist/cjs/core/helpers/getOperatorStringFromProperty.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperatorStringFromProperty = getOperatorStringFromProperty;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Extracts the operator string from a class property declaration, if it
+ * represents an operator overload.
+ *
+ * Handles three property name styles:
+ * - `["+"]` — ComputedPropertyName with a StringLiteral expression
+ * - `[Operator.PLUS]` — ComputedPropertyName with an enum member expression
+ * - `"+"` — StringLiteral property name
+ *
+ * Returns `undefined` if the property name doesn't resolve to an operator string.
+ */
+function getOperatorStringFromProperty(property) {
+    const nameNode = property.getNameNode();
+    if (nameNode.isKind(ts_morph_1.SyntaxKind.ComputedPropertyName)) {
+        const expression = nameNode.getExpression();
+        if (expression.isKind(ts_morph_1.SyntaxKind.StringLiteral)) {
+            return expression.getLiteralValue();
+        }
+        // Handle Operator.PLUS style (enum member access)
+        const literalValue = expression.getType().getLiteralValue();
+        if (typeof literalValue === "string") {
+            return literalValue;
+        }
+    }
+    else if (nameNode.isKind(ts_morph_1.SyntaxKind.StringLiteral)) {
+        return nameNode.getLiteralValue();
+    }
+    return undefined;
+}

package/dist/cjs/core/helpers/resolveExpressionType.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExpressionType = resolveExpressionType;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Resolves the effective type name for a node in a binary expression.
+ *
+ * Handles special cases:
+ * - Numeric literals → `"number"`
+ * - Boolean literals (not in string context) → `"boolean"`
+ * - `"any"` type → falls back to the declared type of the symbol
+ *   (needed for compound assignments where TS can't infer the result type)
+ */
+function resolveExpressionType(node) {
+    var _a;
+    let typeName = node.getType().getText();
+    if (node.getKind() === ts_morph_1.SyntaxKind.NumericLiteral) {
+        return "number";
+    }
+    if (node.getKind() !== ts_morph_1.SyntaxKind.StringLiteral &&
+        (typeName === "true" || typeName === "false")) {
+        return "boolean";
+    }
+    if (typeName === "any") {
+        const decl = (_a = node.getSymbol()) === null || _a === void 0 ? void 0 : _a.getValueDeclaration();
+        if (decl)
+            typeName = decl.getType().getText();
+    }
+    return typeName;
+}

package/dist/cjs/core/helpers/unwrapInitializer.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unwrapInitializer = unwrapInitializer;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Unwraps `as const` and `satisfies` type assertions from an initializer
+ * expression, returning the underlying expression.
+ *
+ * For example, given `[fn1, fn2] as const`, this returns the
+ * `[fn1, fn2]` ArrayLiteralExpression.
+ */
+function unwrapInitializer(initializer) {
+    if (initializer && ts_morph_1.Node.isAsExpression(initializer))
+        initializer = initializer.getExpression();
+    if (initializer && ts_morph_1.Node.isSatisfiesExpression(initializer))
+        initializer = initializer.getExpression();
+    return initializer;
+}

package/dist/cjs/core/operatorMap.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postfixUnaryOperatorStrings = exports.prefixUnaryOperatorStrings = exports.isPostfixUnaryOperatorSyntaxKind = exports.postfixUnaryOperatorSyntaxKinds = exports.postfixUnaryOperatorMap = exports.isPrefixUnaryOperatorSyntaxKind = exports.prefixUnaryOperatorSyntaxKinds = exports.prefixUnaryOperatorMap = exports.comparisonOperators = exports.instanceOperators = exports.isOperatorSyntaxKind = exports.operatorSyntaxKinds = exports.operatorMap = void 0;
+const ts_morph_1 = require("ts-morph");
+const operatorSymbols_1 = require("../lib/operatorSymbols");
+/**
+ * Maps operator string values to their corresponding TypeScript syntax kind.
+ */
+exports.operatorMap = {
+    [operatorSymbols_1.Operator.PLUS]: ts_morph_1.SyntaxKind.PlusToken,
+    [operatorSymbols_1.Operator.PLUS_EQUALS]: ts_morph_1.SyntaxKind.PlusEqualsToken,
+    [operatorSymbols_1.Operator.MINUS]: ts_morph_1.SyntaxKind.MinusToken,
+    [operatorSymbols_1.Operator.MINUS_EQUALS]: ts_morph_1.SyntaxKind.MinusEqualsToken,
+    [operatorSymbols_1.Operator.MULTIPLY]: ts_morph_1.SyntaxKind.AsteriskToken,
+    [operatorSymbols_1.Operator.MULTIPLY_EQUALS]: ts_morph_1.SyntaxKind.AsteriskEqualsToken,
+    [operatorSymbols_1.Operator.DIVIDE]: ts_morph_1.SyntaxKind.SlashToken,
+    [operatorSymbols_1.Operator.DIVIDE_EQUALS]: ts_morph_1.SyntaxKind.SlashEqualsToken,
+    [operatorSymbols_1.Operator.GREATER_THAN]: ts_morph_1.SyntaxKind.GreaterThanToken,
+    [operatorSymbols_1.Operator.GREATER_THAN_EQUAL_TO]: ts_morph_1.SyntaxKind.GreaterThanEqualsToken,
+    [operatorSymbols_1.Operator.LESS_THAN]: ts_morph_1.SyntaxKind.LessThanToken,
+    [operatorSymbols_1.Operator.LESS_THAN_EQUAL_TO]: ts_morph_1.SyntaxKind.LessThanEqualsToken,
+    [operatorSymbols_1.Operator.MODULO]: ts_morph_1.SyntaxKind.PercentToken,
+    [operatorSymbols_1.Operator.MODULO_EQUALS]: ts_morph_1.SyntaxKind.PercentEqualsToken,
+    [operatorSymbols_1.Operator.EQUALS]: ts_morph_1.SyntaxKind.EqualsEqualsToken,
+    [operatorSymbols_1.Operator.STRICT_EQUALS]: ts_morph_1.SyntaxKind.EqualsEqualsEqualsToken,
+    [operatorSymbols_1.Operator.NOT_EQUALS]: ts_morph_1.SyntaxKind.ExclamationEqualsToken,
+    [operatorSymbols_1.Operator.STRICT_NOT_EQUALS]: ts_morph_1.SyntaxKind.ExclamationEqualsEqualsToken,
+    [operatorSymbols_1.Operator.AND]: ts_morph_1.SyntaxKind.AmpersandAmpersandToken,
+    [operatorSymbols_1.Operator.AND_EQUALS]: ts_morph_1.SyntaxKind.AmpersandAmpersandEqualsToken,
+    [operatorSymbols_1.Operator.OR]: ts_morph_1.SyntaxKind.BarBarToken,
+    [operatorSymbols_1.Operator.OR_EQUALS]: ts_morph_1.SyntaxKind.BarBarEqualsToken,
+    [operatorSymbols_1.Operator.NULLISH]: ts_morph_1.SyntaxKind.QuestionQuestionToken,
+};
+exports.operatorSyntaxKinds = Object.values(exports.operatorMap);
+const isOperatorSyntaxKind = (syntaxKind) => exports.operatorSyntaxKinds.includes(syntaxKind);
+exports.isOperatorSyntaxKind = isOperatorSyntaxKind;
+/**
+ * Set of which operators whose overloads should be instance operators
+ * i.e. operate on the LHS object.
+ * These should return void.
+ */
+exports.instanceOperators = new Set([
+    exports.operatorMap[operatorSymbols_1.Operator.PLUS_EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.MINUS_EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.MULTIPLY_EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.DIVIDE_EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.MODULO_EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.AND_EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.OR_EQUALS],
+]);
+/**
+ * Set of operators where the expected return type of their overload is a boolean.
+ */
+exports.comparisonOperators = new Set([
+    exports.operatorMap[operatorSymbols_1.Operator.GREATER_THAN],
+    exports.operatorMap[operatorSymbols_1.Operator.GREATER_THAN_EQUAL_TO],
+    exports.operatorMap[operatorSymbols_1.Operator.LESS_THAN],
+    exports.operatorMap[operatorSymbols_1.Operator.LESS_THAN_EQUAL_TO],
+    exports.operatorMap[operatorSymbols_1.Operator.EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.STRICT_EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.NOT_EQUALS],
+    exports.operatorMap[operatorSymbols_1.Operator.STRICT_NOT_EQUALS],
+]);
+/**
+ * Maps prefix unary operator strings to their corresponding TypeScript syntax kind.
+ * Operators like `-` and `+` share SyntaxKind tokens with their binary counterparts;
+ * disambiguation happens at the AST node level (PrefixUnaryExpression vs BinaryExpression).
+ */
+exports.prefixUnaryOperatorMap = {
+    [operatorSymbols_1.Operator.MINUS]: ts_morph_1.SyntaxKind.MinusToken,
+    [operatorSymbols_1.Operator.PLUS]: ts_morph_1.SyntaxKind.PlusToken,
+    [operatorSymbols_1.Operator.NOT]: ts_morph_1.SyntaxKind.ExclamationToken,
+    [operatorSymbols_1.Operator.BITWISE_NOT]: ts_morph_1.SyntaxKind.TildeToken,
+};
+exports.prefixUnaryOperatorSyntaxKinds = Object.values(exports.prefixUnaryOperatorMap);
+const isPrefixUnaryOperatorSyntaxKind = (syntaxKind) => exports.prefixUnaryOperatorSyntaxKinds.includes(syntaxKind);
+exports.isPrefixUnaryOperatorSyntaxKind = isPrefixUnaryOperatorSyntaxKind;
+/**
+ * Maps postfix unary operator strings to their corresponding TypeScript syntax kind.
+ */
+exports.postfixUnaryOperatorMap = {
+    [operatorSymbols_1.Operator.INCREMENT]: ts_morph_1.SyntaxKind.PlusPlusToken,
+    [operatorSymbols_1.Operator.DECREMENT]: ts_morph_1.SyntaxKind.MinusMinusToken,
+};
+exports.postfixUnaryOperatorSyntaxKinds = Object.values(exports.postfixUnaryOperatorMap);
+const isPostfixUnaryOperatorSyntaxKind = (syntaxKind) => exports.postfixUnaryOperatorSyntaxKinds.includes(syntaxKind);
+exports.isPostfixUnaryOperatorSyntaxKind = isPostfixUnaryOperatorSyntaxKind;
+/**
+ * Set of operator strings that can appear as prefix unary overloads.
+ */
+exports.prefixUnaryOperatorStrings = new Set(Object.keys(exports.prefixUnaryOperatorMap));
+/**
+ * Set of operator strings that can appear as postfix unary overloads.
+ */
+exports.postfixUnaryOperatorStrings = new Set(Object.keys(exports.postfixUnaryOperatorMap));

package/dist/cjs/core/validateExports.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExports = validateExports;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Validate that all classes with registered operator overloads are exported
+ * and (optionally) reachable from a package entry point.
+ *
+ * @param project     The ts-morph project containing the source files.
+ * @param overloadStore  Populated OverloadStore for the project.
+ * @param projectDir  Absolute path to the project root — used to filter out
+ *                    overloads sourced from library dependencies.
+ * @param entryPoint  Absolute path to the source entry point (e.g. `src/index.ts`).
+ *                    When provided, a second pass checks that every overload
+ *                    class is transitively reachable from this file via its
+ *                    export graph. Omit to run the file-level check only.
+ */
+function validateExports({ project, overloadStore, projectDir, entryPoint, }) {
+    var _a;
+    const violations = [];
+    const normalizedDir = projectDir.replace(/\\/g, "/").replace(/\/$/, "");
+    // Deduplicate: collect unique (className, classFilePath) pairs whose
+    // source lives inside this project (skip .d.ts from dependencies).
+    const seen = new Set();
+    const classes = [];
+    for (const overload of overloadStore.getAllOverloads()) {
+        const normalized = overload.classFilePath.replace(/\\/g, "/");
+        const inProject = normalized.startsWith(`${normalizedDir}/`) ||
+            normalized === normalizedDir;
+        if (!inProject)
+            continue;
+        if (normalized.endsWith(".d.ts"))
+            continue;
+        const key = `${overload.className}::${normalized}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            classes.push({
+                className: overload.className,
+                classFilePath: overload.classFilePath,
+            });
+        }
+    }
+    // Level 2 setup: resolve the set of class declarations reachable from the
+    // entry point by walking the full export graph (follows re-exports).
+    let entryExportedClassDecls;
+    if (entryPoint) {
+        const entryFile = (_a = project.getSourceFile(entryPoint)) !== null && _a !== void 0 ? _a : project.addSourceFileAtPath(entryPoint);
+        entryExportedClassDecls = new Set();
+        for (const decls of entryFile.getExportedDeclarations().values()) {
+            for (const decl of decls) {
+                if (ts_morph_1.Node.isClassDeclaration(decl)) {
+                    entryExportedClassDecls.add(decl);
+                }
+            }
+        }
+    }
+    // Check each class.
+    for (const { className, classFilePath } of classes) {
+        const sourceFile = project.getSourceFile(classFilePath);
+        if (!sourceFile)
+            continue;
+        const classDecl = sourceFile.getClass(className);
+        if (!classDecl)
+            continue;
+        // Level 1: is the class exported from its own source file?
+        if (!classDecl.isExported()) {
+            violations.push({
+                className,
+                classFilePath,
+                reason: "not-exported-from-file",
+            });
+            // If not exported from file it cannot be in the entry point graph
+            // either — no need to run the deep check for this class.
+            continue;
+        }
+        // Level 2: is the class reachable from the entry point?
+        if (entryExportedClassDecls !== undefined &&
+            !entryExportedClassDecls.has(classDecl)) {
+            violations.push({
+                className,
+                classFilePath,
+                reason: "not-reachable-from-entry",
+            });
+        }
+    }
+    return { violations };
+}

package/dist/cjs/index.js

@@ -0,0 +1,36 @@
+"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;
+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; } });
+var ErrorManager_1 = require("./core/ErrorManager");
+Object.defineProperty(exports, "ErrorDescription", { enumerable: true, get: function () { return ErrorManager_1.ErrorDescription; } });
+Object.defineProperty(exports, "ErrorManager", { enumerable: true, get: function () { return ErrorManager_1.ErrorManager; } });
+var getOperatorStringFromProperty_1 = require("./core/helpers/getOperatorStringFromProperty");
+Object.defineProperty(exports, "getOperatorStringFromProperty", { enumerable: true, get: function () { return getOperatorStringFromProperty_1.getOperatorStringFromProperty; } });
+var resolveExpressionType_1 = require("./core/helpers/resolveExpressionType");
+Object.defineProperty(exports, "resolveExpressionType", { enumerable: true, get: function () { return resolveExpressionType_1.resolveExpressionType; } });
+var unwrapInitializer_1 = require("./core/helpers/unwrapInitializer");
+Object.defineProperty(exports, "unwrapInitializer", { enumerable: true, get: function () { return unwrapInitializer_1.unwrapInitializer; } });
+var OverloadInjector_1 = require("./core/OverloadInjector");
+Object.defineProperty(exports, "OverloadInjector", { enumerable: true, get: function () { return OverloadInjector_1.OverloadInjector; } });
+var OverloadStore_1 = require("./core/OverloadStore");
+Object.defineProperty(exports, "OverloadStore", { enumerable: true, get: function () { return OverloadStore_1.OverloadStore; } });
+var operatorMap_1 = require("./core/operatorMap");
+Object.defineProperty(exports, "isOperatorSyntaxKind", { enumerable: true, get: function () { return operatorMap_1.isOperatorSyntaxKind; } });
+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; } });
+var validateExports_1 = require("./core/validateExports");
+Object.defineProperty(exports, "validateExports", { enumerable: true, get: function () { return validateExports_1.validateExports; } });
+// Operator definitions
+var operatorSymbols_1 = require("./lib/operatorSymbols");
+Object.defineProperty(exports, "Operator", { enumerable: true, get: function () { return operatorSymbols_1.Operator; } });
+Object.defineProperty(exports, "operatorSymbols", { enumerable: true, get: function () { return operatorSymbols_1.operatorSymbols; } });
+var ts_morph_1 = require("ts-morph");
+Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return ts_morph_1.Node; } });
+Object.defineProperty(exports, "Project", { enumerable: true, get: function () { return ts_morph_1.Project; } });
+Object.defineProperty(exports, "SyntaxKind", { enumerable: true, get: function () { return ts_morph_1.SyntaxKind; } });

package/dist/cjs/lib/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./operatorSymbols"), exports);