@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/TSTransformer/nodes/expressions/transformOmittedExpression.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.transformOmittedExpression = transformOmittedExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function transformOmittedExpression() {
+    return luau_ast_1.default.nil();
+}
+//# sourceMappingURL=transformOmittedExpression.js.map

package/out/TSTransformer/nodes/expressions/transformParenthesizedExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformParenthesizedExpression(state: TransformState, node: ts.ParenthesizedExpression): luau.Identifier | luau.TemporaryIdentifier | luau.ParenthesizedExpression | luau.NilLiteral | luau.FalseLiteral | luau.TrueLiteral | luau.NumberLiteral | luau.StringLiteral;

package/out/TSTransformer/nodes/expressions/transformParenthesizedExpression.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformParenthesizedExpression = transformParenthesizedExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+const traversal_1 = require("../../util/traversal");
+function transformParenthesizedExpression(state, node) {
+    const expression = (0, transformExpression_1.transformExpression)(state, (0, traversal_1.skipDownwards)(node.expression));
+    if (luau_ast_1.default.isSimple(expression)) {
+        return expression;
+    }
+    else {
+        return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ParenthesizedExpression, { expression });
+    }
+}
+//# sourceMappingURL=transformParenthesizedExpression.js.map

package/out/TSTransformer/nodes/expressions/transformPropertyAccessExpression.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformPropertyAccessExpressionInner(state: TransformState, node: ts.PropertyAccessExpression, expression: luau.Expression, name: string): luau.PropertyAccessExpression | luau.None;
+export declare function transformPropertyAccessExpression(state: TransformState, node: ts.PropertyAccessExpression): luau.Expression<luau.SyntaxKind>;

package/out/TSTransformer/nodes/expressions/transformPropertyAccessExpression.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPropertyAccessExpressionInner = transformPropertyAccessExpressionInner;
+exports.transformPropertyAccessExpression = transformPropertyAccessExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformOptionalChain_1 = require("../transformOptionalChain");
+const addIndexDiagnostics_1 = require("../../util/addIndexDiagnostics");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const getConstantValueLiteral_1 = require("../../util/getConstantValueLiteral");
+const traversal_1 = require("../../util/traversal");
+const validateNotAny_1 = require("../../util/validateNotAny");
+const typescript_1 = __importDefault(require("typescript"));
+function transformPropertyAccessExpressionInner(state, node, expression, name) {
+    (0, validateNotAny_1.validateNotAnyType)(state, node.expression);
+    (0, addIndexDiagnostics_1.addIndexDiagnostics)(state, node, state.typeChecker.getNonOptionalType(state.getType(node)));
+    if (typescript_1.default.isDeleteExpression((0, traversal_1.skipUpwards)(node).parent)) {
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(expression), name),
+            operator: "=",
+            right: luau_ast_1.default.nil(),
+        }));
+        return luau_ast_1.default.none();
+    }
+    return luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(expression), name);
+}
+function transformPropertyAccessExpression(state, node) {
+    const constantValue = (0, getConstantValueLiteral_1.getConstantValueLiteral)(state, node);
+    if (constantValue) {
+        return constantValue;
+    }
+    return (0, transformOptionalChain_1.transformOptionalChain)(state, node);
+}
+//# sourceMappingURL=transformPropertyAccessExpression.js.map

package/out/TSTransformer/nodes/expressions/transformSpreadElement.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformSpreadElement(state: TransformState, node: ts.SpreadElement): luau.CallExpression;

package/out/TSTransformer/nodes/expressions/transformSpreadElement.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformSpreadElement = transformSpreadElement;
+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("./transformExpression");
+const getAddIterableToArrayBuilder_1 = require("../../util/getAddIterableToArrayBuilder");
+const types_1 = require("../../util/types");
+const validateNotAny_1 = require("../../util/validateNotAny");
+const typescript_1 = __importDefault(require("typescript"));
+function transformSpreadElement(state, node) {
+    (0, validateNotAny_1.validateNotAnyType)(state, node.expression);
+    (0, assert_1.assert)(!typescript_1.default.isArrayLiteralExpression(node.parent) && node.parent.arguments);
+    if (node.parent.arguments[node.parent.arguments.length - 1] !== node) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrecedingSpreadElement(node));
+    }
+    const expression = (0, transformExpression_1.transformExpression)(state, node.expression);
+    const type = state.getType(node.expression);
+    if ((0, types_1.isDefinitelyType)(type, (0, types_1.isArrayType)(state))) {
+        return luau_ast_1.default.call(luau_ast_1.default.globals.unpack, [expression]);
+    }
+    else {
+        const addIterableToArrayBuilder = (0, getAddIterableToArrayBuilder_1.getAddIterableToArrayBuilder)(state, node.expression, type);
+        const arrayId = state.pushToVar(luau_ast_1.default.array(), "array");
+        const lengthId = state.pushToVar(luau_ast_1.default.number(0), "length");
+        state.prereqList(addIterableToArrayBuilder(state, expression, arrayId, lengthId, 0, false));
+        return luau_ast_1.default.call(luau_ast_1.default.globals.unpack, [arrayId]);
+    }
+}
+//# sourceMappingURL=transformSpreadElement.js.map

package/out/TSTransformer/nodes/expressions/transformStringLiteral.d.ts

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

package/out/TSTransformer/nodes/expressions/transformStringLiteral.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformStringLiteral = transformStringLiteral;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const createStringFromLiteral_1 = require("../../util/createStringFromLiteral");
+function transformStringLiteral(state, node) {
+    return luau_ast_1.default.string((0, createStringFromLiteral_1.createStringFromLiteral)(node));
+}
+//# sourceMappingURL=transformStringLiteral.js.map

package/out/TSTransformer/nodes/expressions/transformSuperKeyword.d.ts

@@ -0,0 +1,2 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function transformSuperKeyword(): luau.Identifier;

package/out/TSTransformer/nodes/expressions/transformSuperKeyword.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.transformSuperKeyword = transformSuperKeyword;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function transformSuperKeyword() {
+    return luau_ast_1.default.globals.super;
+}
+//# sourceMappingURL=transformSuperKeyword.js.map

package/out/TSTransformer/nodes/expressions/transformTaggedTemplateExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformTaggedTemplateExpression(state: TransformState, node: ts.TaggedTemplateExpression): luau.CallExpression;

package/out/TSTransformer/nodes/expressions/transformTaggedTemplateExpression.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.transformTaggedTemplateExpression = transformTaggedTemplateExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const ensureTransformOrder_1 = require("../../util/ensureTransformOrder");
+const typescript_1 = __importDefault(require("typescript"));
+function transformTaggedTemplateExpression(state, node) {
+    const tagExp = (0, transformExpression_1.transformExpression)(state, node.tag);
+    if (typescript_1.default.isTemplateExpression(node.template)) {
+        const strings = new Array();
+        strings.push(luau_ast_1.default.string(node.template.head.text));
+        for (const templateSpan of node.template.templateSpans) {
+            strings.push(luau_ast_1.default.string(templateSpan.literal.text));
+        }
+        const expressions = (0, ensureTransformOrder_1.ensureTransformOrder)(state, node.template.templateSpans.map(templateSpan => templateSpan.expression));
+        return luau_ast_1.default.call((0, convertToIndexableExpression_1.convertToIndexableExpression)(tagExp), [luau_ast_1.default.array(strings), ...expressions]);
+    }
+    else {
+        return luau_ast_1.default.call((0, convertToIndexableExpression_1.convertToIndexableExpression)(tagExp), [luau_ast_1.default.array([luau_ast_1.default.string(node.template.text)])]);
+    }
+}
+//# sourceMappingURL=transformTaggedTemplateExpression.js.map

package/out/TSTransformer/nodes/expressions/transformTemplateExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformTemplateExpression(state: TransformState, node: ts.TemplateExpression): luau.InterpolatedString;

package/out/TSTransformer/nodes/expressions/transformTemplateExpression.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTemplateExpression = transformTemplateExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformInterpolatedStringPart_1 = require("../transformInterpolatedStringPart");
+const ensureTransformOrder_1 = require("../../util/ensureTransformOrder");
+function transformTemplateExpression(state, node) {
+    const parts = luau_ast_1.default.list.make();
+    if (node.head.text.length > 0) {
+        luau_ast_1.default.list.push(parts, (0, transformInterpolatedStringPart_1.transformInterpolatedStringPart)(node.head));
+    }
+    const orderedExpressions = (0, ensureTransformOrder_1.ensureTransformOrder)(state, node.templateSpans.map(templateSpan => templateSpan.expression));
+    for (let i = 0; i < node.templateSpans.length; i++) {
+        luau_ast_1.default.list.push(parts, orderedExpressions[i]);
+        const templateSpan = node.templateSpans[i];
+        if (templateSpan.literal.text.length > 0) {
+            luau_ast_1.default.list.push(parts, (0, transformInterpolatedStringPart_1.transformInterpolatedStringPart)(templateSpan.literal));
+        }
+    }
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.InterpolatedString, { parts });
+}
+//# sourceMappingURL=transformTemplateExpression.js.map

package/out/TSTransformer/nodes/expressions/transformThisExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformThisExpression(state: TransformState, node: ts.ThisExpression): luau.AnyIdentifier;

package/out/TSTransformer/nodes/expressions/transformThisExpression.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformThisExpression = transformThisExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const TSTransformer_1 = require("../..");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const typescript_1 = __importDefault(require("typescript"));
+function transformThisExpression(state, node) {
+    const symbol = state.typeChecker.getSymbolAtLocation(node);
+    if (symbol === state.services.macroManager.getSymbolOrThrow(TSTransformer_1.SYMBOL_NAMES.globalThis)) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noGlobalThis(node));
+    }
+    if (symbol) {
+        const container = typescript_1.default.getThisContainer(node, false, false);
+        const isStatic = typescript_1.default.hasStaticModifier(container) || typescript_1.default.isClassStaticBlockDeclaration(container);
+        if (isStatic && !typescript_1.default.isMethodDeclaration(container) && typescript_1.default.isClassLike(container.parent)) {
+            const identifier = state.classIdentifierMap.get(container.parent);
+            if (identifier) {
+                return identifier;
+            }
+        }
+    }
+    return luau_ast_1.default.globals.self;
+}
+//# sourceMappingURL=transformThisExpression.js.map

package/out/TSTransformer/nodes/expressions/transformTypeExpression.d.ts

@@ -0,0 +1,3 @@
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformTypeExpression(state: TransformState, node: ts.AsExpression | ts.NonNullExpression | ts.SatisfiesExpression | ts.TypeAssertion | ts.ExpressionWithTypeArguments): import("@roblox-ts/luau-ast/out/LuauAST/bundle").Expression<import("@roblox-ts/luau-ast/out/LuauAST/bundle").SyntaxKind>;

package/out/TSTransformer/nodes/expressions/transformTypeExpression.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformTypeExpression = transformTypeExpression;
+const transformExpression_1 = require("./transformExpression");
+function transformTypeExpression(state, node) {
+    return (0, transformExpression_1.transformExpression)(state, node.expression);
+}
+//# sourceMappingURL=transformTypeExpression.js.map

package/out/TSTransformer/nodes/expressions/transformUnaryExpression.d.ts

@@ -0,0 +1,5 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformPostfixUnaryExpression(state: TransformState, node: ts.PostfixUnaryExpression): luau.TemporaryIdentifier;
+export declare function transformPrefixUnaryExpression(state: TransformState, node: ts.PrefixUnaryExpression): luau.Identifier | luau.TemporaryIdentifier | luau.ComputedIndexExpression | luau.PropertyAccessExpression | luau.CallExpression | luau.MethodCallExpression | luau.ParenthesizedExpression | luau.None | luau.NilLiteral | luau.FalseLiteral | luau.TrueLiteral | luau.NumberLiteral | luau.StringLiteral | luau.VarArgsLiteral | luau.FunctionExpression | luau.BinaryExpression | luau.UnaryExpression | luau.IfExpression | luau.InterpolatedString | luau.Array | luau.Map | luau.Set | luau.MixedTable;

package/out/TSTransformer/nodes/expressions/transformUnaryExpression.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformPostfixUnaryExpression = transformPostfixUnaryExpression;
+exports.transformPrefixUnaryExpression = transformPrefixUnaryExpression;
+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("./transformExpression");
+const transformWritable_1 = require("../transformWritable");
+const assertNever_1 = require("../../util/assertNever");
+const createTruthinessChecks_1 = require("../../util/createTruthinessChecks");
+const types_1 = require("../../util/types");
+const validateNotAny_1 = require("../../util/validateNotAny");
+const typescript_1 = __importDefault(require("typescript"));
+function transformPostfixUnaryExpression(state, node) {
+    (0, validateNotAny_1.validateNotAnyType)(state, node.operand);
+    const writable = (0, transformWritable_1.transformWritableExpression)(state, node.operand, true);
+    const origValue = luau_ast_1.default.tempId("original");
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+        left: origValue,
+        right: writable,
+    }));
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+        left: writable,
+        operator: node.operator === typescript_1.default.SyntaxKind.PlusPlusToken
+            ? "+="
+            : node.operator === typescript_1.default.SyntaxKind.MinusMinusToken
+                ? "-="
+                : (0, assertNever_1.assertNever)(node.operator, "transformPostfixUnaryExpression"),
+        right: luau_ast_1.default.number(1),
+    }));
+    return origValue;
+}
+function transformPrefixUnaryExpression(state, node) {
+    (0, validateNotAny_1.validateNotAnyType)(state, node.operand);
+    if (node.operator === typescript_1.default.SyntaxKind.PlusPlusToken || node.operator === typescript_1.default.SyntaxKind.MinusMinusToken) {
+        const writable = (0, transformWritable_1.transformWritableExpression)(state, node.operand, true);
+        const operator = node.operator === typescript_1.default.SyntaxKind.PlusPlusToken ? "+=" : "-=";
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+            left: writable,
+            operator,
+            right: luau_ast_1.default.number(1),
+        }));
+        return writable;
+    }
+    else if (node.operator === typescript_1.default.SyntaxKind.PlusToken) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noUnaryPlus(node));
+        return (0, transformExpression_1.transformExpression)(state, node.operand);
+    }
+    else if (node.operator === typescript_1.default.SyntaxKind.MinusToken) {
+        if (!(0, types_1.isDefinitelyType)(state.getType(node.operand), types_1.isNumberType)) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noNonNumberUnaryMinus(node));
+        }
+        return luau_ast_1.default.unary("-", (0, transformExpression_1.transformExpression)(state, node.operand));
+    }
+    else if (node.operator === typescript_1.default.SyntaxKind.ExclamationToken) {
+        const checks = (0, createTruthinessChecks_1.createTruthinessChecks)(state, (0, transformExpression_1.transformExpression)(state, node.operand), node.operand);
+        return luau_ast_1.default.unary("not", checks);
+    }
+    else if (node.operator === typescript_1.default.SyntaxKind.TildeToken) {
+        return luau_ast_1.default.call(luau_ast_1.default.property(luau_ast_1.default.globals.bit32, "bnot"), [(0, transformExpression_1.transformExpression)(state, node.operand)]);
+    }
+    return (0, assertNever_1.assertNever)(node.operator, "transformPrefixUnaryExpression");
+}
+//# sourceMappingURL=transformUnaryExpression.js.map

package/out/TSTransformer/nodes/expressions/transformVoidExpression.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformVoidExpression(state: TransformState, node: ts.VoidExpression): luau.NilLiteral;

package/out/TSTransformer/nodes/expressions/transformVoidExpression.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.transformVoidExpression = transformVoidExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpressionStatement_1 = require("../statements/transformExpressionStatement");
+const traversal_1 = require("../../util/traversal");
+function transformVoidExpression(state, node) {
+    state.prereqList((0, transformExpressionStatement_1.transformExpressionStatementInner)(state, (0, traversal_1.skipDownwards)(node.expression)));
+    return luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.NilLiteral, {});
+}
+//# sourceMappingURL=transformVoidExpression.js.map

package/out/TSTransformer/nodes/expressions/transformYieldExpression.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 transformYieldExpression(state: TransformState, node: ts.YieldExpression): luau.TemporaryIdentifier | luau.CallExpression | luau.None;

package/out/TSTransformer/nodes/expressions/transformYieldExpression.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformYieldExpression = transformYieldExpression;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const transformExpression_1 = require("./transformExpression");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const isUsedAsStatement_1 = require("../../util/isUsedAsStatement");
+function transformYieldExpression(state, node) {
+    if (!node.expression) {
+        return luau_ast_1.default.call(luau_ast_1.default.globals.coroutine.yield, []);
+    }
+    const expression = (0, transformExpression_1.transformExpression)(state, node.expression);
+    if (node.asteriskToken) {
+        const loopId = luau_ast_1.default.tempId("result");
+        const finalizer = luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BreakStatement, {}));
+        let evaluated = luau_ast_1.default.none();
+        if (!(0, isUsedAsStatement_1.isUsedAsStatement)(node)) {
+            const returnValue = state.pushToVar(undefined, "returnValue");
+            luau_ast_1.default.list.unshift(finalizer, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.Assignment, {
+                left: returnValue,
+                operator: "=",
+                right: luau_ast_1.default.property(loopId, "value"),
+            }));
+            evaluated = returnValue;
+        }
+        state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+            ids: luau_ast_1.default.list.make(loopId),
+            expression: luau_ast_1.default.property((0, convertToIndexableExpression_1.convertToIndexableExpression)(expression), "next"),
+            statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+                condition: luau_ast_1.default.property(loopId, "done"),
+                statements: finalizer,
+                elseBody: luau_ast_1.default.list.make(),
+            }), luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+                expression: luau_ast_1.default.call(luau_ast_1.default.globals.coroutine.yield, [luau_ast_1.default.property(loopId, "value")]),
+            })),
+        }));
+        return evaluated;
+    }
+    else {
+        return luau_ast_1.default.call(luau_ast_1.default.globals.coroutine.yield, [expression]);
+    }
+}
+//# sourceMappingURL=transformYieldExpression.js.map

package/out/TSTransformer/nodes/jsx/transformJsx.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformJsx(state: TransformState, node: ts.JsxElement | ts.JsxSelfClosingElement, tagName: ts.JsxTagNameExpression, attributes: ts.JsxAttributes, children: ReadonlyArray<ts.JsxChild>): luau.CallExpression;

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

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJsx = transformJsx;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const assert_1 = require("../../../Shared/util/assert");
+const transformJsxAttributes_1 = require("./transformJsxAttributes");
+const transformJsxChildren_1 = require("./transformJsxChildren");
+const transformJsxTagName_1 = require("./transformJsxTagName");
+const transformEntityName_1 = require("../transformEntityName");
+const convertToIndexableExpression_1 = require("../../util/convertToIndexableExpression");
+const pointer_1 = require("../../util/pointer");
+function transformJsx(state, node, tagName, attributes, children) {
+    const jsxFactoryEntity = state.resolver.getJsxFactoryEntity(node);
+    (0, assert_1.assert)(jsxFactoryEntity, "Expected jsxFactoryEntity to be defined");
+    const createElementExpression = (0, convertToIndexableExpression_1.convertToIndexableExpression)((0, transformEntityName_1.transformEntityName)(state, jsxFactoryEntity));
+    const tagNameExp = (0, transformJsxTagName_1.transformJsxTagName)(state, tagName);
+    let attributesPtr;
+    if (attributes.properties.length > 0) {
+        attributesPtr = (0, pointer_1.createMapPointer)("attributes");
+        (0, transformJsxAttributes_1.transformJsxAttributes)(state, attributes, attributesPtr);
+    }
+    const transformedChildren = (0, transformJsxChildren_1.transformJsxChildren)(state, children);
+    const args = [tagNameExp];
+    if (attributesPtr) {
+        args.push(attributesPtr.value);
+    }
+    else if (transformedChildren.length > 0) {
+        args.push(luau_ast_1.default.nil());
+    }
+    args.push(...transformedChildren);
+    return luau_ast_1.default.call(createElementExpression, args);
+}
+//# sourceMappingURL=transformJsx.js.map

package/out/TSTransformer/nodes/jsx/transformJsxAttributes.d.ts

@@ -0,0 +1,4 @@
+import { TransformState } from "../..";
+import { MapPointer } from "../../util/pointer";
+import ts from "typescript";
+export declare function transformJsxAttributes(state: TransformState, attributes: ts.JsxAttributes, attributesPtr: MapPointer): void;

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

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJsxAttributes = transformJsxAttributes;
+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 createTruthinessChecks_1 = require("../../util/createTruthinessChecks");
+const pointer_1 = require("../../util/pointer");
+const types_1 = require("../../util/types");
+const typescript_1 = __importDefault(require("typescript"));
+function createJsxAttributeLoop(state, attributesPtrValue, expression, tsExpression) {
+    const definitelyObject = (0, types_1.isDefinitelyType)(state.getType(tsExpression), types_1.isObjectType);
+    if (!definitelyObject) {
+        expression = state.pushToVarIfComplex(expression, "attribute");
+    }
+    const keyId = luau_ast_1.default.tempId("k");
+    const valueId = luau_ast_1.default.tempId("v");
+    let statement = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.ForStatement, {
+        ids: luau_ast_1.default.list.make(keyId, valueId),
+        expression,
+        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: attributesPtrValue,
+                index: keyId,
+            }),
+            operator: "=",
+            right: valueId,
+        })),
+    });
+    if (!definitelyObject) {
+        statement = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+            condition: (0, createTruthinessChecks_1.createTruthinessChecks)(state, expression, tsExpression),
+            statements: luau_ast_1.default.list.make(statement),
+            elseBody: luau_ast_1.default.list.make(),
+        });
+    }
+    return statement;
+}
+function transformJsxAttribute(state, attribute, attributesPtr) {
+    let initializer = attribute.initializer;
+    if (initializer && typescript_1.default.isJsxExpression(initializer)) {
+        initializer = initializer.expression;
+    }
+    const [init, initPrereqs] = initializer
+        ? state.capture(() => (0, transformExpression_1.transformExpression)(state, initializer))
+        : [luau_ast_1.default.bool(true), luau_ast_1.default.list.make()];
+    if (!luau_ast_1.default.list.isEmpty(initPrereqs)) {
+        (0, pointer_1.disableMapInline)(state, attributesPtr);
+        state.prereqList(initPrereqs);
+    }
+    const text = typescript_1.default.isIdentifier(attribute.name) ? attribute.name.text : typescript_1.default.getTextOfJsxNamespacedName(attribute.name);
+    const name = luau_ast_1.default.string(text);
+    (0, pointer_1.assignToMapPointer)(state, attributesPtr, name, init);
+}
+function transformJsxAttributes(state, attributes, attributesPtr) {
+    for (const attribute of attributes.properties) {
+        if (typescript_1.default.isJsxAttribute(attribute)) {
+            transformJsxAttribute(state, attribute, attributesPtr);
+        }
+        else {
+            const expType = state.typeChecker.getNonOptionalType(state.getType(attribute.expression));
+            const symbol = (0, types_1.getFirstDefinedSymbol)(state, expType);
+            if (symbol && state.services.macroManager.isMacroOnlyClass(symbol)) {
+                DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noMacroObjectSpread(attribute));
+            }
+            const expression = (0, transformExpression_1.transformExpression)(state, attribute.expression);
+            if (attribute === attributes.properties[0] && (0, types_1.isDefinitelyType)(expType, types_1.isObjectType)) {
+                attributesPtr.value = state.pushToVar(luau_ast_1.default.call(luau_ast_1.default.globals.table.clone, [expression]), attributesPtr.name);
+                state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+                    expression: luau_ast_1.default.call(luau_ast_1.default.globals.setmetatable, [attributesPtr.value, luau_ast_1.default.nil()]),
+                }));
+                continue;
+            }
+            (0, pointer_1.disableMapInline)(state, attributesPtr);
+            state.prereq(createJsxAttributeLoop(state, attributesPtr.value, expression, attribute.expression));
+        }
+    }
+}
+//# sourceMappingURL=transformJsxAttributes.js.map

package/out/TSTransformer/nodes/jsx/transformJsxChildren.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 transformJsxChildren(state: TransformState, children: ReadonlyArray<ts.JsxChild>): luau.Expression<luau.SyntaxKind>[];

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformJsxChildren = transformJsxChildren;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+const diagnostics_1 = require("../../../Shared/diagnostics");
+const findLastIndex_1 = require("../../../Shared/util/findLastIndex");
+const DiagnosticService_1 = require("../../classes/DiagnosticService");
+const transformExpression_1 = require("../expressions/transformExpression");
+const ensureTransformOrder_1 = require("../../util/ensureTransformOrder");
+const fixupWhitespaceAndDecodeEntities_1 = require("../../util/fixupWhitespaceAndDecodeEntities");
+const typescript_1 = __importDefault(require("typescript"));
+function transformJsxChildren(state, children) {
+    const lastJsxChildIndex = (0, findLastIndex_1.findLastIndex)(children, child => !typescript_1.default.isJsxText(child) || !child.containsOnlyTriviaWhiteSpaces);
+    for (let i = 0; i < lastJsxChildIndex; i++) {
+        const child = children[i];
+        if (typescript_1.default.isJsxExpression(child) && child.dotDotDotToken) {
+            DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noPrecedingJsxSpreadElement(child));
+        }
+    }
+    return (0, ensureTransformOrder_1.ensureTransformOrder)(state, children
+        .filter(v => !typescript_1.default.isJsxText(v) || !v.containsOnlyTriviaWhiteSpaces)
+        .filter(v => !typescript_1.default.isJsxExpression(v) || v.expression !== undefined), (state, node) => {
+        var _a;
+        if (typescript_1.default.isJsxText(node)) {
+            const text = (_a = (0, fixupWhitespaceAndDecodeEntities_1.fixupWhitespaceAndDecodeEntities)(node.text)) !== null && _a !== void 0 ? _a : "";
+            return luau_ast_1.default.string(text.replace(/\\/g, "\\\\"));
+        }
+        return (0, transformExpression_1.transformExpression)(state, node);
+    });
+}
+//# sourceMappingURL=transformJsxChildren.js.map

package/out/TSTransformer/nodes/jsx/transformJsxTagName.d.ts

@@ -0,0 +1,4 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../..";
+import ts from "typescript";
+export declare function transformJsxTagName(state: TransformState, tagName: ts.JsxTagNameExpression): luau.Expression<luau.SyntaxKind>;