rbxts-transform-boost 0.1.0

package/bench/src/shared/fns.ts

@@ -0,0 +1,127 @@
+// ── Vector3 / physics ────────────────────────────────────────────────────────
+
+export function integrate(pos: Vector3, vel: Vector3, acc: Vector3, dt: number): [Vector3, Vector3] {
+    const newVel = vel.add(acc.mul(dt));
+    const newPos = pos.add(newVel.mul(dt));
+    return [newPos, newVel];
+}
+
+export function dot(a: Vector3, b: Vector3): number {
+    return a.X * b.X + a.Y * b.Y + a.Z * b.Z;
+}
+
+export function cross(a: Vector3, b: Vector3): Vector3 {
+    return new Vector3(
+        a.Y * b.Z - a.Z * b.Y,
+        a.Z * b.X - a.X * b.Z,
+        a.X * b.Y - a.Y * b.X,
+    );
+}
+
+export function lerpVec3(a: Vector3, b: Vector3, t: number): Vector3 {
+    return new Vector3(
+        a.X + (b.X - a.X) * t,
+        a.Y + (b.Y - a.Y) * t,
+        a.Z + (b.Z - a.Z) * t,
+    );
+}
+
+// ── Buffer / encoding ────────────────────────────────────────────────────────
+
+export function encodeFixed(buf: buffer, offset: number, value: number, scale: number): number {
+    const fixed = math.floor(value * scale);
+    const clamped = math.clamp(fixed, -32768, 32767);
+    buffer.writei16(buf, offset, clamped);
+    return offset + 2;
+}
+
+export function encodePacket(buf: buffer, x: number, y: number, z: number, scale: number): void {
+    let off = 0;
+    off = encodeFixed(buf, off, x, scale);
+    off = encodeFixed(buf, off, y, scale);
+    encodeFixed(buf, off, z, scale);
+}
+
+// ── Math / arithmetic ────────────────────────────────────────────────────────
+
+export function sumWeighted(values: Array<number>, weights: Array<number>): number {
+    let total = 0;
+    for (let i = 0; i < values.size(); i++) {
+        total += values[i] * weights[i];
+    }
+    return total;
+}
+
+export function dotProduct(a: Array<number>, b: Array<number>): number {
+    let sum = 0;
+    for (let i = 0; i < a.size(); i++) {
+        sum += a[i] * b[i];
+    }
+    return sum;
+}
+
+export function norm(values: Array<number>): number {
+    let sq = 0;
+    for (let i = 0; i < values.size(); i++) {
+        sq += values[i] * values[i];
+    }
+    return math.sqrt(sq);
+}
+
+export function mathHeavy(x: number, y: number): number {
+    return math.sin(x) * math.cos(y) + math.sqrt(x * x + y * y) + math.atan2(y, x);
+}
+
+export function fib(n: number): number {
+    if (n <= 1) return n;
+    let a = 0;
+    let b = 1;
+    for (let i = 2; i <= n; i++) {
+        const tmp = a + b;
+        a = b;
+        b = tmp;
+    }
+    return b;
+}
+
+// ── CFrame ───────────────────────────────────────────────────────────────────
+
+export function cfLookAt(eye: Vector3, target: Vector3): CFrame {
+    return CFrame.lookAt(eye, target);
+}
+
+export function cfChain(cf: CFrame, dt: number): CFrame {
+    return cf.mul(CFrame.Angles(0, dt, 0));
+}
+
+// ── Services / instance ──────────────────────────────────────────────────────
+
+export function serviceWork(): string {
+    const count = game.GetService("Players").GetPlayers().size();
+    const running = game.GetService("RunService").IsRunning();
+    return `${count}-${running}`;
+}
+
+export function multiService(): boolean {
+    const players = game.GetService("Players");
+    const rs = game.GetService("RunService");
+    const ws = game.GetService("Workspace");
+    return rs.IsRunning() && players.MaxPlayers > 0 && ws.Gravity > 0;
+}
+
+export function cameraWork(camera: Camera): number {
+    const pos = camera.CFrame.Position;
+    const look = camera.CFrame.LookVector;
+    const fov = camera.FieldOfView;
+    return pos.Magnitude + look.X + fov;
+}
+
+// ── String ───────────────────────────────────────────────────────────────────
+
+export function formatStats(label: string, value: number, unit: string): string {
+    return `${label}: ${string.format("%.4f", value)} ${unit}`;
+}
+
+export function buildKey(prefix: string, id: number, suffix: string): string {
+    return `${prefix}_${id}_${suffix}`;
+}

package/bench/tsconfig.json

@@ -0,0 +1,32 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "commonjs",
+        "moduleDetection": "force",
+        "moduleResolution": "Node",
+        "strict": true,
+        "noLib": true,
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true,
+        "rootDir": "./src",
+        "outDir": "./out/src",
+        "typeRoots": [
+            "./node_modules/@rbxts"
+        ],
+        "plugins": [
+            {
+                "transform": "rbxts-transform-boost",
+                "optimize": true,
+                "hoist": true
+            }
+        ]
+    },
+    "include": [
+        "./src/server",
+        "./src/shared/fns.ts"
+    ],
+    "rbxts": {
+        "includePath": "out/include"
+    }
+}

package/bench/tsconfig.notransform.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "commonjs",
+        "moduleDetection": "force",
+        "moduleResolution": "Node",
+        "strict": true,
+        "noLib": true,
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
+        "forceConsistentCasingInFileNames": true,
+        "rootDir": "./src",
+        "outDir": "./out/src",
+        "typeRoots": [
+            "./node_modules/@rbxts"
+        ],
+    },
+    "include": [
+        "./src/shared/fns-bare.ts"
+    ],
+    "rbxts": {
+        "includePath": "out/include"
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,4 @@
+export interface PluginConfig {
+    optimize?: boolean;
+    hoist?: boolean;
+}

package/dist/config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type ts from "typescript";
+import type { PluginConfig } from "./config";
+export type { PluginConfig };
+export default function (program: ts.Program, config: PluginConfig | undefined, { ts }: {
+    ts: typeof import("typescript");
+}): ts.TransformerFactory<ts.SourceFile>;

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const native_1 = require("./passes/native");
+const cache_1 = require("./passes/cache");
+const loops_1 = require("./passes/loops");
+const annotate_1 = require("./passes/annotate");
+function default_1(program, config = {}, { ts }) {
+    const { optimize = true, hoist = true } = config;
+    return (ctx) => (sourceFile) => {
+        (0, annotate_1.annotatePass)(ts, program, sourceFile);
+        let result = sourceFile;
+        if (hoist)
+            result = (0, cache_1.cachePass)(ts, program, ctx, result);
+        result = (0, loops_1.loopsPass)(ts, program, ctx, result);
+        if (optimize)
+            result = (0, native_1.nativePass)(ts, ctx, result);
+        return result;
+    };
+}

package/dist/passes/annotate.d.ts

@@ -0,0 +1,2 @@
+import type ts from "typescript";
+export declare function annotatePass(ts: typeof import("typescript"), program: ts.Program, sourceFile: ts.SourceFile): void;

package/dist/passes/annotate.js

@@ -0,0 +1,222 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.annotatePass = annotatePass;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Luau type names for TypeScript type strings rotor knows about
+const LUAU_TYPE = {
+    number: "number",
+    string: "string",
+    boolean: "boolean",
+    Vector3: "Vector3",
+    Vector2: "Vector2",
+    Vector2int16: "Vector2int16",
+    Vector3int16: "Vector3int16",
+    CFrame: "CFrame",
+    UDim: "UDim",
+    UDim2: "UDim2",
+    Color3: "Color3",
+    BrickColor: "BrickColor",
+    TweenInfo: "TweenInfo",
+    NumberRange: "NumberRange",
+    NumberSequence: "NumberSequence",
+    ColorSequence: "ColorSequence",
+    Rect: "Rect",
+    Region3: "Region3",
+    Ray: "Ray",
+    buffer: "buffer",
+    // Roblox service types
+    Instance: "Instance",
+    BasePart: "BasePart",
+    Part: "Part",
+    Model: "Model",
+    Player: "Player",
+    Camera: "Camera",
+    Workspace: "Workspace",
+    RunService: "RunService",
+    Players: "Players",
+    // Luau numeric arrays — kept as {number} in Luau
+};
+// Global sidecar: outLuauPath → list of function annotations for that file
+const sidecar = new Map();
+let hooked = false;
+function luauTypeForTsType(ts, checker, node) {
+    if (node.type) {
+        const mapped = mapTypeNode(ts, node.type);
+        if (mapped)
+            return mapped;
+    }
+    const type = checker.getTypeAtLocation(node);
+    const name = checker.typeToString(type);
+    return LUAU_TYPE[name] ?? null;
+}
+function mapTypeNode(ts, typeNode) {
+    if (ts.isTypeReferenceNode(typeNode)) {
+        const name = ts.isIdentifier(typeNode.typeName) ? typeNode.typeName.text : null;
+        if (!name)
+            return null;
+        if (LUAU_TYPE[name])
+            return LUAU_TYPE[name];
+        // Array<T> → {T}
+        if ((name === "Array" || name === "ReadonlyArray") && typeNode.typeArguments?.length === 1) {
+            const inner = mapTypeNode(ts, typeNode.typeArguments[0]);
+            return inner ? `{${inner}}` : "{any}";
+        }
+        return null;
+    }
+    if (ts.isArrayTypeNode(typeNode)) {
+        const inner = mapTypeNode(ts, typeNode.elementType);
+        return inner ? `{${inner}}` : "{any}";
+    }
+    const kw = {
+        [ts.SyntaxKind.NumberKeyword]: "number",
+        [ts.SyntaxKind.StringKeyword]: "string",
+        [ts.SyntaxKind.BooleanKeyword]: "boolean",
+    };
+    if (typeNode.kind in kw)
+        return kw[typeNode.kind];
+    return null;
+}
+function outPathForSource(sourceFile, program) {
+    const options = program.getCompilerOptions();
+    const outDir = options.outDir;
+    if (!outDir)
+        return null;
+    // Compute rootDir: explicit option or the common root of all source files
+    const rootDir = options.rootDir
+        ?? commonRoot(program.getRootFileNames());
+    if (!rootDir)
+        return null;
+    const rel = path.relative(rootDir, sourceFile.fileName);
+    if (rel.startsWith(".."))
+        return null;
+    // Change .ts / .tsx extension to .luau
+    const luauRel = rel.replace(/\.tsx?$/, ".luau");
+    return path.join(outDir, luauRel);
+}
+function commonRoot(files) {
+    if (files.length === 0)
+        return undefined;
+    const parts = files[0].split(path.sep);
+    let root = parts.slice(0, parts.length - 1);
+    for (const f of files.slice(1)) {
+        const fp = f.split(path.sep);
+        let i = 0;
+        while (i < root.length && i < fp.length - 1 && root[i] === fp[i])
+            i++;
+        root = root.slice(0, i);
+    }
+    return root.join(path.sep) || undefined;
+}
+function collectAnnotations(ts, checker, sourceFile, outPath) {
+    const fileMap = sidecar.get(outPath) ?? new Map();
+    sidecar.set(outPath, fileMap);
+    function visit(node) {
+        if (ts.isFunctionDeclaration(node) && node.name) {
+            const fnName = node.name.text;
+            const params = node.parameters.map(p => luauTypeForTsType(ts, checker, p));
+            if (params.some(p => p !== null)) {
+                fileMap.set(fnName, { params });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+}
+function injectAnnotations(luauPath, fileMap) {
+    if (!fs.existsSync(luauPath))
+        return;
+    let src = fs.readFileSync(luauPath, "utf8");
+    let changed = false;
+    for (const [fnName, ann] of fileMap) {
+        if (ann.params.every(p => p === null))
+            continue;
+        // Match: local function fnName(a, b, c)
+        // Captures the param list so we can replace individual names
+        const re = new RegExp(`(local function ${escapeRegex(fnName)}\\()([^)]*)(\\.\\.\\.\\))?\\)`);
+        src = src.replace(re, (_match, open, rawParams, vararg) => {
+            const names = rawParams.split(",").map((s) => s.trim()).filter(Boolean);
+            const annotated = names.map((name, i) => {
+                // strip any existing annotation
+                const bare = name.split(":")[0].trim();
+                const typ = ann.params[i];
+                return typ ? `${bare}: ${typ}` : bare;
+            });
+            if (vararg)
+                annotated.push("...");
+            changed = true;
+            return `${open}${annotated.join(", ")})`;
+        });
+    }
+    if (changed)
+        fs.writeFileSync(luauPath, src, "utf8");
+}
+function escapeRegex(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function installWatcher(outDir) {
+    if (hooked)
+        return;
+    hooked = true;
+    const seen = new Set();
+    const watcher = fs.watch(outDir, { recursive: true }, (_event, filename) => {
+        if (!filename || !filename.endsWith(".luau"))
+            return;
+        const full = path.join(outDir, filename);
+        if (seen.has(full))
+            return;
+        const fileMap = sidecar.get(full);
+        if (!fileMap)
+            return;
+        seen.add(full);
+        if (fileMap.size > 0) {
+            try {
+                injectAnnotations(full, fileMap);
+            }
+            catch { /* ignore */ }
+        }
+    });
+    watcher.unref();
+}
+function annotatePass(ts, program, sourceFile) {
+    const outPath = outPathForSource(sourceFile, program);
+    if (!outPath)
+        return;
+    const checker = program.getTypeChecker();
+    collectAnnotations(ts, checker, sourceFile, outPath);
+    const outDir = program.getCompilerOptions().outDir;
+    installWatcher(outDir);
+}

package/dist/passes/cache.d.ts

@@ -0,0 +1,2 @@
+import type ts from "typescript";
+export declare function cachePass(ts: typeof import("typescript"), _program: ts.Program, ctx: ts.TransformationContext, sourceFile: ts.SourceFile): ts.SourceFile;

package/dist/passes/cache.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachePass = cachePass;
+const util_1 = require("../util");
+function isGetServiceCall(ts, node) {
+    if (!ts.isCallExpression(node))
+        return false;
+    const expr = node.expression;
+    if (!ts.isPropertyAccessExpression(expr))
+        return false;
+    const obj = expr.expression;
+    return ts.isIdentifier(obj) && obj.text === "game" && expr.name.text === "GetService";
+}
+function getServiceName(ts, call) {
+    const args = call.arguments;
+    if (args.length !== 1)
+        return undefined;
+    const arg = args[0];
+    if (!ts.isStringLiteral(arg))
+        return undefined;
+    return arg.text;
+}
+function cachePass(ts, _program, ctx, sourceFile) {
+    const factory = ctx.factory;
+    // --- GetService hoisting ---
+    const services = new Map();
+    (0, util_1.walk)(ts, sourceFile, node => {
+        if (!node || !isGetServiceCall(ts, node))
+            return;
+        const name = getServiceName(ts, node);
+        if (name && !services.has(name))
+            services.set(name, `_${name}`);
+    });
+    const serviceVisitor = (node) => {
+        if (isGetServiceCall(ts, node)) {
+            const name = getServiceName(ts, node);
+            if (name && services.has(name))
+                return factory.createIdentifier(services.get(name));
+        }
+        return ts.visitEachChild(node, serviceVisitor, ctx);
+    };
+    let result = ts.visitEachChild(sourceFile, serviceVisitor, ctx);
+    if (services.size > 0) {
+        const hoistDecls = Array.from(services.entries()).map(([name, localName]) => factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(localName), undefined, undefined, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("game"), "GetService"), undefined, [factory.createStringLiteral(name)]))], ts.NodeFlags.Const)));
+        result = factory.updateSourceFile(result, [...hoistDecls, ...Array.from(result.statements)]);
+    }
+    // --- Property chain hoisting within functions ---
+    result = hoistPropertyChains(ts, result, factory, ctx);
+    return result;
+}
+function hoistPropertyChains(ts, sourceFile, factory, ctx) {
+    const visitor = (node) => {
+        if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) ||
+            ts.isArrowFunction(node) || ts.isMethodDeclaration(node)) {
+            return hoistInFunction(ts, node, factory, ctx);
+        }
+        return ts.visitEachChild(node, visitor, ctx);
+    };
+    return ts.visitEachChild(sourceFile, visitor, ctx);
+}
+function hoistInFunction(ts, fn, factory, ctx) {
+    if (!fn.body || !ts.isBlock(fn.body))
+        return fn;
+    const counts = new Map();
+    (0, util_1.walk)(ts, fn.body, node => {
+        if (!node || !ts.isPropertyAccessExpression(node))
+            return;
+        const key = (0, util_1.chainKey)(ts, node);
+        if (!key || !key.includes("."))
+            return;
+        if ((0, util_1.isAssignmentTarget)(ts, node))
+            return;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    });
+    const toHoist = new Map();
+    let counter = 0;
+    const candidates = Array.from(counts.entries())
+        .filter(([, count]) => count >= 2)
+        .sort((a, b) => b[0].length - a[0].length);
+    for (const [key] of candidates) {
+        const alreadyCovered = Array.from(toHoist.keys()).some(h => h.startsWith(key + "."));
+        if (alreadyCovered)
+            continue;
+        toHoist.set(key, `_cache${counter++}`);
+    }
+    if (toHoist.size === 0)
+        return fn;
+    const chainVisitor = (node) => {
+        if (ts.isPropertyAccessExpression(node)) {
+            const key = (0, util_1.chainKey)(ts, node);
+            if (key && toHoist.has(key) && !(0, util_1.isAssignmentTarget)(ts, node)) {
+                return factory.createIdentifier(toHoist.get(key));
+            }
+        }
+        return ts.visitEachChild(node, chainVisitor, ctx);
+    };
+    const newBody = ts.visitEachChild(fn.body, chainVisitor, ctx);
+    const hoistStmts = Array.from(toHoist.entries()).map(([key, localName]) => {
+        const parts = key.split(".");
+        let expr = factory.createIdentifier(parts[0]);
+        for (let i = 1; i < parts.length; i++) {
+            expr = factory.createPropertyAccessExpression(expr, parts[i]);
+        }
+        return factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(localName), undefined, undefined, expr)], ts.NodeFlags.Const));
+    });
+    const updatedBody = factory.updateBlock(newBody, [...hoistStmts, ...Array.from(newBody.statements)]);
+    if (ts.isFunctionDeclaration(fn))
+        return factory.updateFunctionDeclaration(fn, fn.modifiers, fn.asteriskToken, fn.name, fn.typeParameters, fn.parameters, fn.type, updatedBody);
+    if (ts.isFunctionExpression(fn))
+        return factory.updateFunctionExpression(fn, fn.modifiers, fn.asteriskToken, fn.name, fn.typeParameters, fn.parameters, fn.type, updatedBody);
+    if (ts.isArrowFunction(fn))
+        return factory.updateArrowFunction(fn, fn.modifiers, fn.typeParameters, fn.parameters, fn.type, fn.equalsGreaterThanToken, updatedBody);
+    if (ts.isMethodDeclaration(fn))
+        return factory.updateMethodDeclaration(fn, fn.modifiers, fn.asteriskToken, fn.name, fn.questionToken, fn.typeParameters, fn.parameters, fn.type, updatedBody);
+    return fn;
+}

package/dist/passes/loops.d.ts

@@ -0,0 +1,2 @@
+import type ts from "typescript";
+export declare function loopsPass(ts: typeof import("typescript"), _program: ts.Program, ctx: ts.TransformationContext, sourceFile: ts.SourceFile): ts.SourceFile;

package/dist/passes/loops.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loopsPass = loopsPass;
+function loopsPass(ts, _program, ctx, sourceFile) {
+    const factory = ctx.factory;
+    function isArrayLengthExpr(node) {
+        // matches: arr.size() or arr.length (if it ever appears)
+        if (ts.isCallExpression(node)) {
+            const expr = node.expression;
+            if (ts.isPropertyAccessExpression(expr) && expr.name.text === "size" && node.arguments.length === 0) {
+                return expr.expression;
+            }
+        }
+        return undefined;
+    }
+    function rewriteForLoop(node) {
+        // Match: for (let i = 0; i < arr.size(); i++) { ... }
+        const { initializer, condition, incrementor, statement } = node;
+        if (!initializer || !condition || !incrementor)
+            return node;
+        if (!ts.isVariableDeclarationList(initializer))
+            return node;
+        const decls = initializer.declarations;
+        if (decls.length !== 1)
+            return node;
+        const decl = decls[0];
+        if (!ts.isIdentifier(decl.name))
+            return node;
+        if (!decl.initializer || !ts.isNumericLiteral(decl.initializer) || decl.initializer.text !== "0")
+            return node;
+        if (!ts.isBinaryExpression(condition))
+            return node;
+        if (condition.operatorToken.kind !== ts.SyntaxKind.LessThanToken)
+            return node;
+        const arr = isArrayLengthExpr(condition.right);
+        if (!arr)
+            return node;
+        const loopVar = decl.name.text;
+        const arrName = ts.isIdentifier(arr) ? arr.text : undefined;
+        if (!arrName)
+            return node;
+        const lenName = `_len_${arrName}`;
+        const lenDecl = factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(factory.createIdentifier(lenName), undefined, factory.createTypeReferenceNode("number"), factory.createCallExpression(factory.createPropertyAccessExpression(arr, "size"), undefined, []))], ts.NodeFlags.Const));
+        const newCondition = factory.updateBinaryExpression(condition, condition.left, condition.operatorToken, factory.createIdentifier(lenName));
+        const newFor = factory.updateForStatement(node, initializer, newCondition, incrementor, statement);
+        return factory.createBlock([lenDecl, newFor], true);
+    }
+    const visitor = (node) => {
+        if (ts.isForStatement(node)) {
+            return rewriteForLoop(node);
+        }
+        return ts.visitEachChild(node, visitor, ctx);
+    };
+    return ts.visitEachChild(sourceFile, visitor, ctx);
+}

package/dist/passes/native.d.ts

@@ -0,0 +1,2 @@
+import type ts from "typescript";
+export declare function nativePass(ts: typeof import("typescript"), ctx: ts.TransformationContext, sourceFile: ts.SourceFile): ts.SourceFile;

package/dist/passes/native.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativePass = nativePass;
+const util_1 = require("../util");
+function nativePass(ts, ctx, sourceFile) {
+    if ((0, util_1.hasOptimizeDirective)(sourceFile))
+        return sourceFile;
+    const factory = ctx.factory;
+    const optimize = ts.addSyntheticLeadingComment(factory.createNotEmittedStatement(sourceFile), ts.SyntaxKind.SingleLineCommentTrivia, "!optimize 2", true);
+    return factory.updateSourceFile(sourceFile, [optimize, ...Array.from(sourceFile.statements)]);
+}

package/dist/util.d.ts

@@ -0,0 +1,5 @@
+import type ts from "typescript";
+export declare function hasOptimizeDirective(sourceFile: ts.SourceFile): boolean;
+export declare function chainKey(ts: typeof import("typescript"), node: ts.Expression): string | undefined;
+export declare function walk(ts: typeof import("typescript"), node: ts.Node, visitor: (n: ts.Node) => void): void;
+export declare function isAssignmentTarget(ts: typeof import("typescript"), node: ts.Node): boolean;