@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/util/cleanModuleName.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanModuleName = cleanModuleName;
+function cleanModuleName(name) {
+    return name.replace(/\W/g, "_");
+}
+//# sourceMappingURL=cleanModuleName.js.map

package/out/TSTransformer/util/convertToIndexableExpression.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function convertToIndexableExpression(expression: luau.IndexableExpression): void;
+export declare function convertToIndexableExpression(expression: luau.Expression): luau.IndexableExpression;

package/out/TSTransformer/util/convertToIndexableExpression.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.convertToIndexableExpression = convertToIndexableExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function convertToIndexableExpression(expression) {
+    if (luau_ast_1.default.isIndexableExpression(expression)) {
+        return expression;
+    }
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ParenthesizedExpression, { expression });
+}
+//# sourceMappingURL=convertToIndexableExpression.js.map

package/out/TSTransformer/util/createBinaryFromOperator.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../classes/TransformState";
+import ts from "typescript";
+export declare function createBinaryFromOperator(state: TransformState, node: ts.Node, left: luau.Expression, leftType: ts.Type, operatorKind: ts.BinaryOperator, right: luau.Expression, rightType: ts.Type): luau.Expression;

package/out/TSTransformer/util/createBinaryFromOperator.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBinaryFromOperator = createBinaryFromOperator;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../Shared/util/assert");
+const bitwise_1 = require("./bitwise");
+const getKindName_1 = require("./getKindName");
+const types_1 = require("./types");
+const wrapExpressionStatement_1 = require("./wrapExpressionStatement");
+const typescript_1 = __importDefault(require("typescript"));
+const OPERATOR_MAP = new Map([
+    [typescript_1.default.SyntaxKind.LessThanToken, "<"],
+    [typescript_1.default.SyntaxKind.GreaterThanToken, ">"],
+    [typescript_1.default.SyntaxKind.LessThanEqualsToken, "<="],
+    [typescript_1.default.SyntaxKind.GreaterThanEqualsToken, ">="],
+    [typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken, "=="],
+    [typescript_1.default.SyntaxKind.ExclamationEqualsEqualsToken, "~="],
+    [typescript_1.default.SyntaxKind.MinusToken, "-"],
+    [typescript_1.default.SyntaxKind.AsteriskToken, "*"],
+    [typescript_1.default.SyntaxKind.SlashToken, "/"],
+    [typescript_1.default.SyntaxKind.AsteriskAsteriskToken, "^"],
+    [typescript_1.default.SyntaxKind.PercentToken, "%"],
+]);
+function createBinaryAdd(left, leftType, right, rightType) {
+    const leftIsString = (0, types_1.isDefinitelyType)(leftType, types_1.isStringType);
+    const rightIsString = (0, types_1.isDefinitelyType)(rightType, types_1.isStringType);
+    if (leftIsString || rightIsString) {
+        return luau_ast_1.default.binary(leftIsString ? left : luau_ast_1.default.call(luau_ast_1.default.globals.tostring, [left]), "..", rightIsString ? right : luau_ast_1.default.call(luau_ast_1.default.globals.tostring, [right]));
+    }
+    else {
+        return luau_ast_1.default.binary(left, "+", right);
+    }
+}
+function createBinaryFromOperator(state, node, left, leftType, operatorKind, right, rightType) {
+    const operator = OPERATOR_MAP.get(operatorKind);
+    if (operator !== undefined) {
+        return luau_ast_1.default.binary(left, operator, right);
+    }
+    if (operatorKind === typescript_1.default.SyntaxKind.PlusToken || operatorKind === typescript_1.default.SyntaxKind.PlusEqualsToken) {
+        return createBinaryAdd(left, leftType, right, rightType);
+    }
+    if ((0, bitwise_1.isBitwiseOperator)(operatorKind)) {
+        return (0, bitwise_1.createBitwiseCall)(operatorKind, [left, right]);
+    }
+    if (operatorKind === typescript_1.default.SyntaxKind.CommaToken) {
+        state.prereqList((0, wrapExpressionStatement_1.wrapExpressionStatement)(left));
+        return right;
+    }
+    (0, assert_1.assert)(false, `createBinaryFromOperator unknown operator: ${(0, getKindName_1.getKindName)(operatorKind)}`);
+}
+//# sourceMappingURL=createBinaryFromOperator.js.map

package/out/TSTransformer/util/createGetService.d.ts

@@ -0,0 +1,2 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function createGetService(serviceName: string): luau.MethodCallExpression;

package/out/TSTransformer/util/createGetService.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGetService = createGetService;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function createGetService(serviceName) {
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MethodCallExpression, {
+        expression: luau_ast_1.default.globals.game,
+        name: "GetService",
+        args: luau_ast_1.default.list.make(luau_ast_1.default.string(serviceName)),
+    });
+}
+//# sourceMappingURL=createGetService.js.map

package/out/TSTransformer/util/createHoistDeclaration.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function createHoistDeclaration(state: TransformState, statement: ts.Statement | ts.CaseClause): luau.VariableDeclaration | undefined;

package/out/TSTransformer/util/createHoistDeclaration.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHoistDeclaration = createHoistDeclaration;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformIdentifier_1 = require("../nodes/expressions/transformIdentifier");
+const validateIdentifier_1 = require("./validateIdentifier");
+function createHoistDeclaration(state, statement) {
+    const hoists = state.hoistsByStatement.get(statement);
+    if (hoists && hoists.length > 0) {
+        hoists.forEach(hoist => (0, validateIdentifier_1.validateIdentifier)(state, hoist));
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+            left: luau_ast_1.default.list.make(...hoists.map(hoistId => (0, transformIdentifier_1.transformIdentifierDefined)(state, hoistId))),
+            right: undefined,
+        });
+    }
+}
+//# sourceMappingURL=createHoistDeclaration.js.map

package/out/TSTransformer/util/createImportExpression.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function getImportParts(state: TransformState, sourceFile: ts.SourceFile, moduleSpecifier: ts.Expression): luau.Expression<luau.SyntaxKind>[];
+export declare function createImportExpression(state: TransformState, sourceFile: ts.SourceFile, moduleSpecifier: ts.Expression): luau.IndexableExpression;

package/out/TSTransformer/util/createImportExpression.js

@@ -0,0 +1,181 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImportParts = getImportParts;
+exports.createImportExpression = createImportExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const rojo_resolver_1 = require("@roblox-ts/rojo-resolver");
+const path_1 = __importDefault(require("path"));
+const constants_1 = require("../../Shared/constants");
+const diagnostics_1 = require("../../Shared/diagnostics");
+const assert_1 = require("../../Shared/util/assert");
+const getCanonicalFileName_1 = require("../../Shared/util/getCanonicalFileName");
+const isPathDescendantOf_1 = require("../../Shared/util/isPathDescendantOf");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+const createGetService_1 = require("./createGetService");
+const expressionChain_1 = require("./expressionChain");
+const getSourceFileFromModuleSpecifier_1 = require("./getSourceFileFromModuleSpecifier");
+const typescript_1 = __importDefault(require("typescript"));
+function getAbsoluteImport(moduleRbxPath) {
+    const pathExpressions = new Array();
+    const serviceName = moduleRbxPath[0];
+    (0, assert_1.assert)(serviceName);
+    pathExpressions.push((0, createGetService_1.createGetService)(serviceName));
+    for (let i = 1; i < moduleRbxPath.length; i++) {
+        pathExpressions.push(luau_ast_1.default.string(moduleRbxPath[i]));
+    }
+    return pathExpressions;
+}
+function getRelativeImport(sourceRbxPath, moduleRbxPath) {
+    const relativePath = rojo_resolver_1.RojoResolver.relative(sourceRbxPath, moduleRbxPath);
+    const path = new Array();
+    let i = 0;
+    while (relativePath[i] === rojo_resolver_1.RbxPathParent) {
+        path.push(constants_1.PARENT_FIELD);
+        i++;
+    }
+    const pathExpressions = [(0, expressionChain_1.propertyAccessExpressionChain)(luau_ast_1.default.globals.script, path)];
+    for (; i < relativePath.length; i++) {
+        const pathPart = relativePath[i];
+        (0, assert_1.assert)(typeof pathPart === "string");
+        pathExpressions.push(luau_ast_1.default.string(pathPart));
+    }
+    return pathExpressions;
+}
+function validateModule(state, scope) {
+    const scopedModules = path_1.default.join(state.data.nodeModulesPath, scope);
+    if (state.compilerOptions.typeRoots) {
+        for (const typeRoot of state.compilerOptions.typeRoots) {
+            if (path_1.default.normalize(scopedModules) === path_1.default.normalize(typeRoot)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function findRelativeRbxPath(moduleOutPath, pkgRojoResolvers) {
+    for (const pkgRojoResolver of pkgRojoResolvers) {
+        const relativeRbxPath = pkgRojoResolver.getRbxPathFromFilePath(moduleOutPath);
+        if (relativeRbxPath) {
+            return relativeRbxPath;
+        }
+    }
+}
+function getNodeModulesImportParts(state, sourceFile, moduleSpecifier, moduleOutPath) {
+    const moduleScope = path_1.default.relative(state.data.nodeModulesPath, moduleOutPath).split(path_1.default.sep)[0];
+    (0, assert_1.assert)(moduleScope);
+    if (!moduleScope.startsWith("@")) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noUnscopedModule(moduleSpecifier));
+        return [luau_ast_1.default.none()];
+    }
+    if (!validateModule(state, moduleScope)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noInvalidModule(moduleSpecifier));
+        return [luau_ast_1.default.none()];
+    }
+    if (state.projectType === constants_1.ProjectType.Package) {
+        const relativeRbxPath = findRelativeRbxPath(moduleOutPath, state.pkgRojoResolvers);
+        if (!relativeRbxPath) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noRojoData(moduleSpecifier, path_1.default.relative(state.data.projectPath, moduleOutPath), true));
+            return [luau_ast_1.default.none()];
+        }
+        const moduleName = relativeRbxPath[0];
+        (0, assert_1.assert)(moduleName);
+        return [
+            (0, expressionChain_1.propertyAccessExpressionChain)(luau_ast_1.default.call(state.TS(moduleSpecifier.parent, "getModule"), [
+                luau_ast_1.default.globals.script,
+                luau_ast_1.default.string(moduleScope),
+                luau_ast_1.default.string(moduleName),
+            ]), relativeRbxPath.slice(1)),
+        ];
+    }
+    else {
+        const moduleRbxPath = state.rojoResolver.getRbxPathFromFilePath(moduleOutPath);
+        if (!moduleRbxPath) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noRojoData(moduleSpecifier, path_1.default.relative(state.data.projectPath, moduleOutPath), true));
+            return [luau_ast_1.default.none()];
+        }
+        const indexOfScope = moduleRbxPath.indexOf(moduleScope);
+        if (indexOfScope === -1 || moduleRbxPath[indexOfScope - 1] !== constants_1.NODE_MODULES) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPackageImportWithoutScope(moduleSpecifier, path_1.default.relative(state.data.projectPath, moduleOutPath), moduleRbxPath));
+            return [luau_ast_1.default.none()];
+        }
+        return getProjectImportParts(state, sourceFile, moduleSpecifier, moduleOutPath, moduleRbxPath);
+    }
+}
+function getProjectImportParts(state, sourceFile, moduleSpecifier, moduleOutPath, moduleRbxPath) {
+    const moduleRbxType = state.rojoResolver.getRbxTypeFromFilePath(moduleOutPath);
+    if (moduleRbxType === rojo_resolver_1.RbxType.Script || moduleRbxType === rojo_resolver_1.RbxType.LocalScript) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noNonModuleImport(moduleSpecifier));
+        return [luau_ast_1.default.none()];
+    }
+    const sourceOutPath = state.pathTranslator.getOutputPath(sourceFile.fileName);
+    const sourceRbxPath = state.rojoResolver.getRbxPathFromFilePath(sourceOutPath);
+    if (!sourceRbxPath) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noRojoData(sourceFile, path_1.default.relative(state.data.projectPath, sourceOutPath), false));
+        return [luau_ast_1.default.none()];
+    }
+    if (state.projectType === constants_1.ProjectType.Game) {
+        if (!typescript_1.default.isImportCall(moduleSpecifier.parent) &&
+            state.rojoResolver.getNetworkType(moduleRbxPath) === rojo_resolver_1.NetworkType.Server &&
+            state.rojoResolver.getNetworkType(sourceRbxPath) !== rojo_resolver_1.NetworkType.Server) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noServerImport(moduleSpecifier));
+            return [luau_ast_1.default.none()];
+        }
+        const fileRelation = state.rojoResolver.getFileRelation(sourceRbxPath, moduleRbxPath);
+        if (fileRelation === rojo_resolver_1.FileRelation.OutToOut || fileRelation === rojo_resolver_1.FileRelation.InToOut) {
+            return getAbsoluteImport(moduleRbxPath);
+        }
+        else if (fileRelation === rojo_resolver_1.FileRelation.InToIn) {
+            return getRelativeImport(sourceRbxPath, moduleRbxPath);
+        }
+        else {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noIsolatedImport(moduleSpecifier));
+            return [luau_ast_1.default.none()];
+        }
+    }
+    else {
+        return getRelativeImport(sourceRbxPath, moduleRbxPath);
+    }
+}
+function getImportParts(state, sourceFile, moduleSpecifier) {
+    var _a;
+    const moduleFile = (0, getSourceFileFromModuleSpecifier_1.getSourceFileFromModuleSpecifier)(state, moduleSpecifier);
+    if (!moduleFile) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noModuleSpecifierFile(moduleSpecifier));
+        return [luau_ast_1.default.none()];
+    }
+    const virtualPath = state.guessVirtualPath(moduleFile.fileName) || moduleFile.fileName;
+    if (typescript_1.default.isInsideNodeModules(virtualPath)) {
+        const moduleOutPath = state.pathTranslator.getImportPath((_a = state.nodeModulesPathMapping.get((0, getCanonicalFileName_1.getCanonicalFileName)(path_1.default.normalize(virtualPath)))) !== null && _a !== void 0 ? _a : virtualPath, true);
+        return getNodeModulesImportParts(state, sourceFile, moduleSpecifier, moduleOutPath);
+    }
+    else {
+        const modulePathTranslator = state.getPathTranslatorForFile(virtualPath);
+        let moduleOutPath;
+        if ((0, isPathDescendantOf_1.isPathDescendantOf)(virtualPath, modulePathTranslator.rootDir)) {
+            moduleOutPath = modulePathTranslator.getImportPath(virtualPath);
+        }
+        else if ((0, isPathDescendantOf_1.isPathDescendantOf)(virtualPath, modulePathTranslator.outDir)) {
+            const relativePath = path_1.default.relative(modulePathTranslator.outDir, virtualPath);
+            const sourcePath = path_1.default.join(modulePathTranslator.rootDir, relativePath);
+            moduleOutPath = modulePathTranslator.getImportPath(sourcePath);
+        }
+        else {
+            moduleOutPath = virtualPath;
+        }
+        const moduleRbxPath = state.rojoResolver.getRbxPathFromFilePath(moduleOutPath);
+        if (!moduleRbxPath) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noRojoData(moduleSpecifier, path_1.default.relative(state.data.projectPath, moduleOutPath), false));
+            return [luau_ast_1.default.none()];
+        }
+        return getProjectImportParts(state, sourceFile, moduleSpecifier, moduleOutPath, moduleRbxPath);
+    }
+}
+function createImportExpression(state, sourceFile, moduleSpecifier) {
+    const parts = getImportParts(state, sourceFile, moduleSpecifier);
+    parts.unshift(luau_ast_1.default.globals.script);
+    return luau_ast_1.default.call(state.TS(moduleSpecifier.parent, "import"), parts);
+}
+//# sourceMappingURL=createImportExpression.js.map

package/out/TSTransformer/util/createStringFromLiteral.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function createStringFromLiteral(node: ts.TemplateLiteralToken | ts.StringLiteral): string;

package/out/TSTransformer/util/createStringFromLiteral.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStringFromLiteral = createStringFromLiteral;
+const typescript_1 = __importDefault(require("typescript"));
+const TEMPLATE_EDGE = "`".length;
+const TEMPLATE_EXP_START = "${".length;
+const TEMPLATE_EXP_END = "}".length;
+function createStringFromLiteral(node) {
+    let text = node.getText();
+    if (typescript_1.default.isStringLiteral(node) || typescript_1.default.isNoSubstitutionTemplateLiteral(node)) {
+        text = typescript_1.default.stripQuotes(text);
+    }
+    else if (typescript_1.default.isTemplateHead(node)) {
+        text = text.slice(TEMPLATE_EDGE, -TEMPLATE_EXP_START);
+    }
+    else if (typescript_1.default.isTemplateMiddle(node)) {
+        text = text.slice(TEMPLATE_EXP_END, -TEMPLATE_EXP_START);
+    }
+    else if (typescript_1.default.isTemplateTail(node)) {
+        text = text.slice(TEMPLATE_EXP_END, -TEMPLATE_EDGE);
+    }
+    return text;
+}
+//# sourceMappingURL=createStringFromLiteral.js.map

package/out/TSTransformer/util/createTransformServices.d.ts

@@ -0,0 +1,3 @@
+import { TransformServices } from "../types";
+import ts from "typescript";
+export declare function createTransformServices(typeChecker: ts.TypeChecker): TransformServices;

package/out/TSTransformer/util/createTransformServices.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransformServices = createTransformServices;
+const TSTransformer_1 = require("..");
+function createTransformServices(typeChecker) {
+    const macroManager = new TSTransformer_1.MacroManager(typeChecker);
+    return { macroManager };
+}
+//# sourceMappingURL=createTransformServices.js.map

package/out/TSTransformer/util/createTruthinessChecks.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function willCreateTruthinessChecks(type: ts.Type): boolean;
+export declare function createTruthinessChecks(state: TransformState, exp: luau.Expression, node: ts.Expression): luau.Expression<luau.SyntaxKind>;

package/out/TSTransformer/util/createTruthinessChecks.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.willCreateTruthinessChecks = willCreateTruthinessChecks;
+exports.createTruthinessChecks = createTruthinessChecks;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../Shared/diagnostics");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+const expressionChain_1 = require("./expressionChain");
+const types_1 = require("./types");
+function willCreateTruthinessChecks(type) {
+    return ((0, types_1.isPossiblyType)(type, (0, types_1.isNumberLiteralType)(0)) ||
+        (0, types_1.isPossiblyType)(type, types_1.isNaNType) ||
+        (0, types_1.isPossiblyType)(type, types_1.isEmptyStringType));
+}
+function createTruthinessChecks(state, exp, node) {
+    const type = state.getType(node);
+    const isAssignableToZero = (0, types_1.isPossiblyType)(type, (0, types_1.isNumberLiteralType)(0));
+    const isAssignableToNaN = (0, types_1.isPossiblyType)(type, types_1.isNaNType);
+    const isAssignableToEmptyString = (0, types_1.isPossiblyType)(type, types_1.isEmptyStringType);
+    if (isAssignableToZero || isAssignableToNaN || isAssignableToEmptyString) {
+        exp = state.pushToVarIfComplex(exp, "value");
+    }
+    const checks = new Array();
+    if (isAssignableToZero) {
+        checks.push(luau_ast_1.default.binary(exp, "~=", luau_ast_1.default.number(0)));
+    }
+    if (isAssignableToZero || isAssignableToNaN) {
+        checks.push(luau_ast_1.default.binary(exp, "==", exp));
+    }
+    if (isAssignableToEmptyString) {
+        checks.push(luau_ast_1.default.binary(exp, "~=", luau_ast_1.default.string("")));
+    }
+    checks.push(exp);
+    if (state.data.projectOptions.logTruthyChanges &&
+        (isAssignableToZero || isAssignableToNaN || isAssignableToEmptyString)) {
+        const checkStrs = new Array();
+        if (isAssignableToZero)
+            checkStrs.push("0");
+        if (isAssignableToZero || isAssignableToNaN)
+            checkStrs.push("NaN");
+        if (isAssignableToEmptyString)
+            checkStrs.push('""');
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.warnings.truthyChange(checkStrs.join(", "))(node));
+    }
+    return (0, expressionChain_1.binaryExpressionChain)(checks, "and");
+}
+//# sourceMappingURL=createTruthinessChecks.js.map

package/out/TSTransformer/util/createTypeCheck.d.ts

@@ -0,0 +1,2 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function createTypeCheck(expression: luau.Expression, typeName: luau.StringLiteral): luau.BinaryExpression;

package/out/TSTransformer/util/createTypeCheck.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTypeCheck = createTypeCheck;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function createTypeCheck(expression, typeName) {
+    return luau_ast_1.default.binary(luau_ast_1.default.call(luau_ast_1.default.globals.type, [expression]), "==", typeName);
+}
+//# sourceMappingURL=createTypeCheck.js.map

package/out/TSTransformer/util/ensureTransformOrder.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function ensureTransformOrder(state: TransformState, nodes: ReadonlyArray<ts.Expression>, transformer?: (state: TransformState, node: ts.Expression) => luau.Expression): Array<luau.Expression>;
+export declare function ensureTransformOrder<T extends ts.Node>(state: TransformState, nodes: ReadonlyArray<T>, transformer: (state: TransformState, node: T) => luau.Expression): Array<luau.Expression>;

package/out/TSTransformer/util/ensureTransformOrder.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureTransformOrder = ensureTransformOrder;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const findLastIndex_1 = require("../../Shared/util/findLastIndex");
+const transformExpression_1 = require("../nodes/expressions/transformExpression");
+const isSymbolMutable_1 = require("./isSymbolMutable");
+const typescript_1 = __importDefault(require("typescript"));
+function ensureTransformOrder(state, nodes, transformer = transformExpression_1.transformExpression) {
+    const expressionInfoList = nodes.map(node => state.capture(() => transformer(state, node)));
+    const lastArgWithPrereqsIndex = (0, findLastIndex_1.findLastIndex)(expressionInfoList, ([, prereqs]) => !luau_ast_1.default.list.isEmpty(prereqs));
+    const result = new Array();
+    for (let i = 0; i < expressionInfoList.length; i++) {
+        const [expression, prereqs] = expressionInfoList[i];
+        state.prereqList(prereqs);
+        let isConstVar = false;
+        const exp = nodes[i];
+        if (typescript_1.default.isIdentifier(exp)) {
+            const symbol = state.typeChecker.getSymbolAtLocation(exp);
+            if (symbol && !(0, isSymbolMutable_1.isSymbolMutable)(state, symbol)) {
+                isConstVar = true;
+            }
+        }
+        if (i < lastArgWithPrereqsIndex &&
+            !luau_ast_1.default.isSimplePrimitive(expression) &&
+            !luau_ast_1.default.isTemporaryIdentifier(expression) &&
+            !isConstVar) {
+            result.push(state.pushToVar(expression, "exp"));
+        }
+        else {
+            result.push(expression);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=ensureTransformOrder.js.map

package/out/TSTransformer/util/expressionChain.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function binaryExpressionChain(expressions: Array<luau.Expression>, operator: luau.BinaryOperator): luau.Expression;
+export declare function propertyAccessExpressionChain(expression: luau.Expression, names: Array<string>): luau.IndexableExpression;

package/out/TSTransformer/util/expressionChain.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binaryExpressionChain = binaryExpressionChain;
+exports.propertyAccessExpressionChain = propertyAccessExpressionChain;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const convertToIndexableExpression_1 = require("./convertToIndexableExpression");
+function binaryExpressionChain(expressions, operator) {
+    return expressions.reduce((acc, current) => luau_ast_1.default.binary(acc, operator, current));
+}
+function propertyAccessExpressionChain(expression, names) {
+    return names.reduce((acc, current) => luau_ast_1.default.property(acc, current), (0, convertToIndexableExpression_1.convertToIndexableExpression)(expression));
+}
+//# sourceMappingURL=expressionChain.js.map

package/out/TSTransformer/util/expressionMightMutate.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function expressionMightMutate(state: TransformState, expression: luau.Expression, node?: ts.Expression): boolean;

package/out/TSTransformer/util/expressionMightMutate.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expressionMightMutate = expressionMightMutate;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const isSymbolMutable_1 = require("./isSymbolMutable");
+const traversal_1 = require("./traversal");
+const typescript_1 = __importDefault(require("typescript"));
+function expressionMightMutate(state, expression, node) {
+    if (luau_ast_1.default.isTemporaryIdentifier(expression)) {
+        return false;
+    }
+    else if (luau_ast_1.default.isParenthesizedExpression(expression)) {
+        return expressionMightMutate(state, expression.expression);
+    }
+    else if (luau_ast_1.default.isSimplePrimitive(expression)) {
+        return false;
+    }
+    else if (luau_ast_1.default.isFunctionExpression(expression)) {
+        return false;
+    }
+    else if (luau_ast_1.default.isVarArgsLiteral(expression)) {
+        return false;
+    }
+    else if (luau_ast_1.default.isIfExpression(expression)) {
+        return (expressionMightMutate(state, expression.condition) ||
+            expressionMightMutate(state, expression.expression) ||
+            expressionMightMutate(state, expression.alternative));
+    }
+    else if (luau_ast_1.default.isBinaryExpression(expression)) {
+        return expressionMightMutate(state, expression.left) || expressionMightMutate(state, expression.right);
+    }
+    else if (luau_ast_1.default.isUnaryExpression(expression)) {
+        return expressionMightMutate(state, expression.expression);
+    }
+    else if (luau_ast_1.default.isArray(expression) || luau_ast_1.default.isSet(expression)) {
+        return luau_ast_1.default.list.some(expression.members, member => expressionMightMutate(state, member));
+    }
+    else if (luau_ast_1.default.isMap(expression)) {
+        return luau_ast_1.default.list.some(expression.fields, field => expressionMightMutate(state, field.index) || expressionMightMutate(state, field.value));
+    }
+    else {
+        if (node) {
+            node = (0, traversal_1.skipDownwards)(node);
+            if (typescript_1.default.isIdentifier(node)) {
+                const symbol = state.typeChecker.getSymbolAtLocation(node);
+                if (symbol && !(0, isSymbolMutable_1.isSymbolMutable)(state, symbol)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=expressionMightMutate.js.map

package/out/TSTransformer/util/findConstructor.d.ts

@@ -0,0 +1,4 @@
+import ts from "typescript";
+export declare function findConstructor(node: ts.ClassLikeDeclaration): (ts.ConstructorDeclaration & {
+    body: ts.Block;
+}) | undefined;

package/out/TSTransformer/util/findConstructor.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConstructor = findConstructor;
+const typescript_1 = __importDefault(require("typescript"));
+function findConstructor(node) {
+    return node.members.find((member) => typescript_1.default.isConstructorDeclaration(member) && member.body !== undefined);
+}
+//# sourceMappingURL=findConstructor.js.map

package/out/TSTransformer/util/fixupWhitespaceAndDecodeEntities.d.ts

@@ -0,0 +1 @@
+export declare function fixupWhitespaceAndDecodeEntities(text: string): string | undefined;