@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/nodes/jsx/transformJsxTagName.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJsxTagName = transformJsxTagName;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformExpression_1 = require("../expressions/transformExpression");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const typescript_1 = __importDefault(require("typescript"));
+function transformJsxTagNameExpression(state, node) {
+    if (typescript_1.default.isIdentifier(node)) {
+        const firstChar = node.text[0];
+        if (firstChar === firstChar.toLowerCase()) {
+            return luau_ast_1.default.string(node.text);
+        }
+    }
+    if (typescript_1.default.isPropertyAccessExpression(node)) {
+        if (typescript_1.default.isPrivateIdentifier(node.name)) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrivateIdentifier(node.name));
+        }
+        return luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)((0, transformExpression_1.transformExpression)(state, node.expression)), node.name.text);
+    }
+    else if (typescript_1.default.isJsxNamespacedName(node)) {
+        return luau_ast_1.default.string(typescript_1.default.getTextOfJsxNamespacedName(node));
+    }
+    else {
+        return (0, transformExpression_1.transformExpression)(state, node);
+    }
+}
+function transformJsxTagName(state, tagName) {
+    const [expression, prereqs] = state.capture(() => transformJsxTagNameExpression(state, tagName));
+    let tagNameExp = expression;
+    if (!luau_ast_1.default.list.isEmpty(prereqs)) {
+        state.prereqList(prereqs);
+        tagNameExp = state.pushToVarIfComplex(tagNameExp, "tagName");
+    }
+    return tagNameExp;
+}
+//# sourceMappingURL=transformJsxTagName.js.map

package/out/TSTransformer/nodes/statements/transformBlock.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformBlock(state: TransformState, node: ts.Block): luau.List<luau.DoStatement>;

package/out/TSTransformer/nodes/statements/transformBlock.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBlock = transformBlock;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformStatementList_1 = require("../transformStatementList");
+function transformBlock(state, node) {
+    return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.DoStatement, {
+        statements: (0, transformStatementList_1.transformStatementList)(state, node, node.statements),
+    }));
+}
+//# sourceMappingURL=transformBlock.js.map

package/out/TSTransformer/nodes/statements/transformBreakStatement.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformBreakStatement(state: TransformState, node: ts.BreakStatement): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/statements/transformBreakStatement.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformBreakStatement = transformBreakStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const isBlockedByTryStatement_1 = require("../../util/isBlockedByTryStatement");
+function transformBreakStatement(state, node) {
+    if (node.label) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noLabeledStatement(node.label));
+        return luau_ast_1.default.list.make();
+    }
+    if ((0, isBlockedByTryStatement_1.isBreakBlockedByTryStatement)(node)) {
+        state.markTryUses("usesBreak");
+        return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+            expression: state.TS(node, "TRY_BREAK"),
+        }));
+    }
+    return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BreakStatement, {}));
+}
+//# sourceMappingURL=transformBreakStatement.js.map

package/out/TSTransformer/nodes/statements/transformClassDeclaration.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformClassDeclaration(state: TransformState, node: ts.ClassDeclaration): import("@roblox-ts/luau-ast/out/LuauAST/bundle").List<import("@roblox-ts/luau-ast/out/LuauAST/bundle").Statement<import("@roblox-ts/luau-ast/out/LuauAST/bundle").SyntaxKind>>;

package/out/TSTransformer/nodes/statements/transformClassDeclaration.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformClassDeclaration = transformClassDeclaration;
+const transformClassLikeDeclaration_1 = require("../class/transformClassLikeDeclaration");
+function transformClassDeclaration(state, node) {
+    return (0, transformClassLikeDeclaration_1.transformClassLikeDeclaration)(state, node).statements;
+}
+//# sourceMappingURL=transformClassDeclaration.js.map

package/out/TSTransformer/nodes/statements/transformContinueStatement.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformContinueStatement(state: TransformState, node: ts.ContinueStatement): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/statements/transformContinueStatement.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformContinueStatement = transformContinueStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const isBlockedByTryStatement_1 = require("../../util/isBlockedByTryStatement");
+function transformContinueStatement(state, node) {
+    if (node.label) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noLabeledStatement(node.label));
+        return luau_ast_1.default.list.make();
+    }
+    if ((0, isBlockedByTryStatement_1.isBreakBlockedByTryStatement)(node)) {
+        state.markTryUses("usesContinue");
+        return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, {
+            expression: state.TS(node, "TRY_CONTINUE"),
+        }));
+    }
+    return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ContinueStatement, {}));
+}
+//# sourceMappingURL=transformContinueStatement.js.map

package/out/TSTransformer/nodes/statements/transformDoStatement.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformDoStatement(state: TransformState, { expression, statement }: ts.DoStatement): luau.List<luau.RepeatStatement>;

package/out/TSTransformer/nodes/statements/transformDoStatement.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformDoStatement = transformDoStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformStatementList_1 = require("../transformStatementList");
+const createTruthinessChecks_1 = require("../../util/createTruthinessChecks");
+const getStatements_1 = require("../../util/getStatements");
+const typescript_1 = __importDefault(require("typescript"));
+function transformDoStatement(state, { expression, statement }) {
+    const statements = (0, transformStatementList_1.transformStatementList)(state, statement, (0, getStatements_1.getStatements)(statement));
+    let conditionIsInvertedInLuau = true;
+    if (typescript_1.default.isPrefixUnaryExpression(expression) && expression.operator === typescript_1.default.SyntaxKind.ExclamationToken) {
+        expression = expression.operand;
+        conditionIsInvertedInLuau = false;
+    }
+    const [condition, conditionPrereqs] = state.capture(() => (0, createTruthinessChecks_1.createTruthinessChecks)(state, (0, transformExpression_1.transformExpression)(state, expression), expression));
+    const repeatStatements = luau_ast_1.default.list.make();
+    luau_ast_1.default.list.push(repeatStatements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.DoStatement, {
+        statements,
+    }));
+    luau_ast_1.default.list.pushList(repeatStatements, conditionPrereqs);
+    return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.RepeatStatement, {
+        statements: repeatStatements,
+        condition: conditionIsInvertedInLuau ? luau_ast_1.default.unary("not", condition) : condition,
+    }));
+}
+//# sourceMappingURL=transformDoStatement.js.map

package/out/TSTransformer/nodes/statements/transformEnumDeclaration.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformEnumDeclaration(state: TransformState, node: ts.EnumDeclaration): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/statements/transformEnumDeclaration.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformEnumDeclaration = transformEnumDeclaration;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const assert_1 = require("../../../Shared/util/assert");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformIdentifier_1 = require("../expressions/transformIdentifier");
+const transformPropertyName_1 = require("../transformPropertyName");
+const expressionMightMutate_1 = require("../../util/expressionMightMutate");
+const hasMultipleDefinitions_1 = require("../../util/hasMultipleDefinitions");
+const validateIdentifier_1 = require("../../util/validateIdentifier");
+const typescript_1 = __importDefault(require("typescript"));
+function needsInverseEntry(state, member) {
+    return typeof state.typeChecker.getConstantValue(member) !== "string";
+}
+function transformEnumDeclaration(state, node) {
+    if (typescript_1.default.hasSyntacticModifier(node, typescript_1.default.ModifierFlags.Const) && state.compilerOptions.preserveConstEnums !== true) {
+        return luau_ast_1.default.list.make();
+    }
+    const symbol = state.typeChecker.getSymbolAtLocation(node.name);
+    if (symbol &&
+        (0, hasMultipleDefinitions_1.hasMultipleDefinitions)(symbol, declaration => typescript_1.default.isEnumDeclaration(declaration) && !typescript_1.default.hasSyntacticModifier(declaration, typescript_1.default.ModifierFlags.Const))) {
+        DiagnosticService_1.DiagnosticService.addDiagnosticWithCache(symbol, diagnostics_1.errors.noEnumMerging(node), state.multiTransformState.isReportedByMultipleDefinitionsCache);
+        return luau_ast_1.default.list.make();
+    }
+    (0, validateIdentifier_1.validateIdentifier)(state, node.name);
+    const left = (0, transformIdentifier_1.transformIdentifierDefined)(state, node.name);
+    const isHoisted = symbol !== undefined && state.isHoisted.get(symbol) === true;
+    if (node.members.every(member => !needsInverseEntry(state, member))) {
+        const right = luau_ast_1.default.map(node.members.map(member => [
+            state.pushToVarIfComplex((0, transformPropertyName_1.transformPropertyName)(state, member.name)),
+            luau_ast_1.default.string(state.typeChecker.getConstantValue(member)),
+        ]));
+        return luau_ast_1.default.list.make(isHoisted
+            ? luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, { left, operator: "=", right })
+            : luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, { left, right }));
+    }
+    const statements = state.capturePrereqs(() => {
+        const inverseId = state.pushToVar(luau_ast_1.default.map(), "inverse");
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left,
+            operator: "=",
+            right: luau_ast_1.default.call(luau_ast_1.default.globals.setmetatable, [
+                luau_ast_1.default.map(),
+                luau_ast_1.default.map([[luau_ast_1.default.strings.__index, inverseId]]),
+            ]),
+        }));
+        for (const member of node.members) {
+            const name = (0, transformPropertyName_1.transformPropertyName)(state, member.name);
+            const index = (0, expressionMightMutate_1.expressionMightMutate)(state, name, typescript_1.default.isComputedPropertyName(member.name) ? member.name.expression : member.name)
+                ?
+                    state.pushToVar(name)
+                : name;
+            const value = state.typeChecker.getConstantValue(member);
+            let valueExp;
+            if (typeof value === "string") {
+                valueExp = luau_ast_1.default.string(value);
+            }
+            else if (typeof value === "number") {
+                valueExp = luau_ast_1.default.number(value);
+            }
+            else {
+                (0, assert_1.assert)(member.initializer);
+                valueExp = state.pushToVarIfComplex((0, transformExpression_1.transformExpression)(state, member.initializer), "value");
+            }
+            state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                    expression: left,
+                    index,
+                }),
+                operator: "=",
+                right: valueExp,
+            }));
+            if (needsInverseEntry(state, member)) {
+                state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                    left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                        expression: inverseId,
+                        index: valueExp,
+                    }),
+                    operator: "=",
+                    right: index,
+                }));
+            }
+        }
+    });
+    const list = luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.DoStatement, { statements }));
+    if (!isHoisted) {
+        luau_ast_1.default.list.unshift(list, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, { left, right: undefined }));
+    }
+    return list;
+}
+//# sourceMappingURL=transformEnumDeclaration.js.map

package/out/TSTransformer/nodes/statements/transformExportAssignment.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformExportAssignment(state: TransformState, node: ts.ExportAssignment): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/statements/transformExportAssignment.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformExportAssignment = transformExportAssignment;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformExpression_1 = require("../expressions/transformExpression");
+const isSymbolMutable_1 = require("../../util/isSymbolMutable");
+const isSymbolOfValue_1 = require("../../util/isSymbolOfValue");
+const typescript_1 = __importDefault(require("typescript"));
+function transformExportEquals(state, node) {
+    state.hasExportEquals = true;
+    const sourceFile = node.getSourceFile();
+    const finalStatement = sourceFile.statements[sourceFile.statements.length - 1];
+    if (finalStatement === node) {
+        return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ReturnStatement, { expression: (0, transformExpression_1.transformExpression)(state, node.expression) }));
+    }
+    else {
+        return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: state.getModuleIdFromNode(node),
+            right: (0, transformExpression_1.transformExpression)(state, node.expression),
+        }));
+    }
+}
+function transformExportDefault(state, node) {
+    const statements = luau_ast_1.default.list.make();
+    const [expression, prereqs] = state.capture(() => (0, transformExpression_1.transformExpression)(state, node.expression));
+    luau_ast_1.default.list.pushList(statements, prereqs);
+    luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+        left: luau_ast_1.default.id("default"),
+        right: expression,
+    }));
+    return statements;
+}
+function transformExportAssignment(state, node) {
+    const symbol = state.typeChecker.getSymbolAtLocation(node.expression);
+    if (symbol && (0, isSymbolMutable_1.isSymbolMutable)(state, symbol)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noExportAssignmentLet(node));
+    }
+    if (symbol && !(0, isSymbolOfValue_1.isSymbolOfValue)(typescript_1.default.skipAlias(symbol, state.typeChecker))) {
+        return luau_ast_1.default.list.make();
+    }
+    if (node.isExportEquals) {
+        return transformExportEquals(state, node);
+    }
+    else {
+        return transformExportDefault(state, node);
+    }
+}
+//# sourceMappingURL=transformExportAssignment.js.map

package/out/TSTransformer/nodes/statements/transformExportDeclaration.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformExportDeclaration(state: TransformState, node: ts.ExportDeclaration): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/statements/transformExportDeclaration.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformExportDeclaration = transformExportDeclaration;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../../Shared/util/assert");
+const cleanModuleName_1 = require("../../util/cleanModuleName");
+const createImportExpression_1 = require("../../util/createImportExpression");
+const isSymbolOfValue_1 = require("../../util/isSymbolOfValue");
+const typescript_1 = __importDefault(require("typescript"));
+function isExportSpecifierValue(state, element) {
+    if (element.isTypeOnly) {
+        return false;
+    }
+    if (state.resolver.isReferencedAliasDeclaration(element)) {
+        return true;
+    }
+    const aliasSymbol = state.typeChecker.getSymbolAtLocation(element.name);
+    if (aliasSymbol && (0, isSymbolOfValue_1.isSymbolOfValue)(typescript_1.default.skipAlias(aliasSymbol, state.typeChecker))) {
+        return true;
+    }
+    return false;
+}
+function countImportExpUses(state, exportClause) {
+    let uses = 0;
+    if (exportClause && typescript_1.default.isNamedExports(exportClause)) {
+        for (const element of exportClause.elements) {
+            if (isExportSpecifierValue(state, element)) {
+                uses++;
+            }
+        }
+    }
+    else {
+        uses++;
+    }
+    return uses;
+}
+function transformExportFrom(state, node) {
+    var _a;
+    (0, assert_1.assert)(node.moduleSpecifier && typescript_1.default.isStringLiteral(node.moduleSpecifier));
+    const statements = luau_ast_1.default.list.make();
+    let importExp;
+    const exportClause = node.exportClause;
+    const uses = countImportExpUses(state, exportClause);
+    if (uses === 1) {
+        importExp = (0, createImportExpression_1.createImportExpression)(state, node.getSourceFile(), node.moduleSpecifier);
+    }
+    else if (uses > 1) {
+        const moduleName = node.moduleSpecifier.text.split("/");
+        importExp = luau_ast_1.default.tempId((0, cleanModuleName_1.cleanModuleName)(moduleName[moduleName.length - 1]));
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: importExp,
+            right: (0, createImportExpression_1.createImportExpression)(state, node.getSourceFile(), node.moduleSpecifier),
+        }));
+    }
+    if (!importExp) {
+        return statements;
+    }
+    const moduleId = state.getModuleIdFromNode(node);
+    if (exportClause) {
+        if (typescript_1.default.isNamedExports(exportClause)) {
+            for (const element of exportClause.elements) {
+                if (isExportSpecifierValue(state, element)) {
+                    luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                        left: luau_ast_1.default.property(moduleId, element.name.text),
+                        operator: "=",
+                        right: luau_ast_1.default.property(importExp, ((_a = element.propertyName) !== null && _a !== void 0 ? _a : element.name).text),
+                    }));
+                }
+            }
+        }
+        else {
+            luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: luau_ast_1.default.property(moduleId, exportClause.name.text),
+                operator: "=",
+                right: importExp,
+            }));
+        }
+    }
+    else {
+        const keyId = luau_ast_1.default.tempId("k");
+        const valueId = luau_ast_1.default.tempId("v");
+        luau_ast_1.default.list.push(statements, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+            ids: luau_ast_1.default.list.make(keyId, valueId),
+            expression: luau_ast_1.default.binary(importExp, "or", luau_ast_1.default.map()),
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ComputedIndexExpression, {
+                    expression: moduleId,
+                    index: keyId,
+                }),
+                operator: "=",
+                right: valueId,
+            })),
+        }));
+    }
+    state.hasExportFrom = true;
+    return statements;
+}
+function transformExportDeclaration(state, node) {
+    if (node.isTypeOnly)
+        return luau_ast_1.default.list.make();
+    if (node.moduleSpecifier) {
+        return transformExportFrom(state, node);
+    }
+    return luau_ast_1.default.list.make();
+}
+//# sourceMappingURL=transformExportDeclaration.js.map

package/out/TSTransformer/nodes/statements/transformExpressionStatement.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformExpressionStatementInner(state: TransformState, expression: ts.Expression): luau.List<luau.Statement>;
+export declare function transformExpressionStatement(state: TransformState, node: ts.ExpressionStatement): luau.List<luau.Statement<luau.SyntaxKind>>;

package/out/TSTransformer/nodes/statements/transformExpressionStatement.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformExpressionStatementInner = transformExpressionStatementInner;
+exports.transformExpressionStatement = transformExpressionStatement;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("../expressions/transformExpression");
+const transformLogicalOrCoalescingAssignmentExpression_1 = require("../transformLogicalOrCoalescingAssignmentExpression");
+const transformWritable_1 = require("../transformWritable");
+const typeGuards_1 = require("../../typeGuards");
+const assignment_1 = require("../../util/assignment");
+const getAssignableValue_1 = require("../../util/getAssignableValue");
+const traversal_1 = require("../../util/traversal");
+const wrapExpressionStatement_1 = require("../../util/wrapExpressionStatement");
+const typescript_1 = __importDefault(require("typescript"));
+function transformUnaryExpressionStatement(state, node) {
+    const writable = (0, transformWritable_1.transformWritableExpression)(state, node.operand, false);
+    const operator = node.operator === typescript_1.default.SyntaxKind.PlusPlusToken ? "+=" : "-=";
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: writable,
+        operator,
+        right: luau_ast_1.default.number(1),
+    });
+}
+function transformExpressionStatementInner(state, expression) {
+    if (typescript_1.default.isBinaryExpression(expression)) {
+        const operatorKind = expression.operatorToken.kind;
+        if (typescript_1.default.isLogicalOrCoalescingAssignmentExpression(expression)) {
+            return (0, transformLogicalOrCoalescingAssignmentExpression_1.transformLogicalOrCoalescingAssignmentExpressionStatement)(state, expression);
+        }
+        else if (typescript_1.default.isAssignmentOperator(operatorKind) &&
+            !typescript_1.default.isArrayLiteralExpression(expression.left) &&
+            !typescript_1.default.isObjectLiteralExpression(expression.left)) {
+            const writableType = state.getType(expression.left);
+            const valueType = state.getType(expression.right);
+            const operator = (0, assignment_1.getSimpleAssignmentOperator)(writableType, operatorKind, valueType);
+            const { writable, readable, value } = (0, transformWritable_1.transformWritableAssignment)(state, expression.left, expression.right, operator === undefined, operator === undefined);
+            if (operator !== undefined) {
+                return luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                    left: writable,
+                    operator,
+                    right: (0, getAssignableValue_1.getAssignableValue)(operator, value, valueType),
+                }));
+            }
+            else {
+                return luau_ast_1.default.list.make((0, assignment_1.createCompoundAssignmentStatement)(state, expression, writable, writableType, readable, operatorKind, value, valueType));
+            }
+        }
+    }
+    else if ((typescript_1.default.isPrefixUnaryExpression(expression) || typescript_1.default.isPostfixUnaryExpression(expression)) &&
+        (0, typeGuards_1.isUnaryAssignmentOperator)(expression.operator)) {
+        return luau_ast_1.default.list.make(transformUnaryExpressionStatement(state, expression));
+    }
+    return (0, wrapExpressionStatement_1.wrapExpressionStatement)((0, transformExpression_1.transformExpression)(state, expression));
+}
+function transformExpressionStatement(state, node) {
+    const expression = (0, traversal_1.skipDownwards)(node.expression);
+    return transformExpressionStatementInner(state, expression);
+}
+//# sourceMappingURL=transformExpressionStatement.js.map

package/out/TSTransformer/nodes/statements/transformForOfStatement.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformForOfRangeMacro(state: TransformState, node: ts.ForOfStatement, macroCall: ts.CallExpression): luau.List<luau.Statement>;
+export declare function transformForOfStatement(state: TransformState, node: ts.ForOfStatement): luau.List<luau.Statement>;