@jackctaylor/roblox-ts 3.0.0-projectrefs.0

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function getKindName(kind: ts.SyntaxKind): string;

package/out/TSTransformer/util/getKindName.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKindName = getKindName;
+const typescript_1 = __importDefault(require("typescript"));
+function getKindName(kind) {
+    if (kind === typescript_1.default.SyntaxKind.FirstAssignment)
+        return "EqualsToken";
+    if (kind === typescript_1.default.SyntaxKind.FirstCompoundAssignment)
+        return "PlusEqualsToken";
+    if (kind === typescript_1.default.SyntaxKind.LastReservedWord)
+        return "WithKeyword";
+    if (kind === typescript_1.default.SyntaxKind.FirstKeyword)
+        return "BreakKeyword";
+    if (kind === typescript_1.default.SyntaxKind.FirstFutureReservedWord)
+        return "ImplementsKeyword";
+    if (kind === typescript_1.default.SyntaxKind.LastFutureReservedWord)
+        return "YieldKeyword";
+    if (kind === typescript_1.default.SyntaxKind.FirstTypeNode)
+        return "TypePredicate";
+    if (kind === typescript_1.default.SyntaxKind.LastTypeNode)
+        return "ImportType";
+    if (kind === typescript_1.default.SyntaxKind.FirstPunctuation)
+        return "OpenBraceToken";
+    if (kind === typescript_1.default.SyntaxKind.FirstToken)
+        return "Unknown";
+    if (kind === typescript_1.default.SyntaxKind.FirstTriviaToken)
+        return "SingleLineCommentTrivia";
+    if (kind === typescript_1.default.SyntaxKind.LastTriviaToken)
+        return "ConflictMarkerTrivia";
+    if (kind === typescript_1.default.SyntaxKind.FirstLiteralToken)
+        return "NumericLiteral";
+    if (kind === typescript_1.default.SyntaxKind.FirstTemplateToken)
+        return "NoSubstitutionTemplateLiteral";
+    if (kind === typescript_1.default.SyntaxKind.LastTemplateToken)
+        return "TemplateTail";
+    if (kind === typescript_1.default.SyntaxKind.FirstBinaryOperator)
+        return "LessThanToken";
+    if (kind === typescript_1.default.SyntaxKind.LastBinaryOperator)
+        return "CaretEqualsToken";
+    if (kind === typescript_1.default.SyntaxKind.FirstStatement)
+        return "VariableStatement";
+    if (kind === typescript_1.default.SyntaxKind.LastStatement)
+        return "DebuggerStatement";
+    if (kind === typescript_1.default.SyntaxKind.FirstNode)
+        return "QualifiedName";
+    if (kind === typescript_1.default.SyntaxKind.FirstJSDocNode)
+        return "JSDocTypeExpression";
+    if (kind === typescript_1.default.SyntaxKind.FirstJSDocTagNode)
+        return "JSDocTag";
+    if (kind === typescript_1.default.SyntaxKind.LastJSDocTagNode)
+        return "JSDocPropertyTag";
+    if (kind === typescript_1.default.SyntaxKind.FirstContextualKeyword)
+        return "AbstractKeyword";
+    if (kind === typescript_1.default.SyntaxKind.LastContextualKeyword)
+        return "OfKeyword";
+    return typescript_1.default.SyntaxKind[kind];
+}
+//# sourceMappingURL=getKindName.js.map

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function getOriginalSymbolOfNode(typeChecker: ts.TypeChecker, node: ts.Node): ts.Symbol | undefined;

package/out/TSTransformer/util/getOriginalSymbolOfNode.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.getOriginalSymbolOfNode = getOriginalSymbolOfNode;
+const typescript_1 = __importDefault(require("typescript"));
+function getOriginalSymbolOfNode(typeChecker, node) {
+    const symbol = typeChecker.getSymbolAtLocation(node);
+    if (symbol) {
+        return typescript_1.default.skipAlias(symbol, typeChecker);
+    }
+    return symbol;
+}
+//# sourceMappingURL=getOriginalSymbolOfNode.js.map

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

@@ -0,0 +1,3 @@
+import { TransformState } from "../classes/TransformState";
+import ts from "typescript";
+export declare function getSourceFileFromModuleSpecifier(state: TransformState, moduleSpecifier: ts.Expression): ts.SourceFile | undefined;

package/out/TSTransformer/util/getSourceFileFromModuleSpecifier.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSourceFileFromModuleSpecifier = getSourceFileFromModuleSpecifier;
+const typescript_1 = __importDefault(require("typescript"));
+function getSourceFileFromModuleSpecifier(state, moduleSpecifier) {
+    var _a;
+    const symbol = (_a = state.typeChecker.getSymbolAtLocation(moduleSpecifier)) !== null && _a !== void 0 ? _a : state.typeChecker.resolveExternalModuleName(moduleSpecifier);
+    if (symbol) {
+        const declaration = symbol.valueDeclaration;
+        if (declaration && typescript_1.default.isModuleDeclaration(declaration) && typescript_1.default.isStringLiteralLike(declaration.name)) {
+            const sourceFile = moduleSpecifier.getSourceFile();
+            const mode = state.program.getModeForUsageLocation(sourceFile, declaration.name);
+            const resolvedModuleInfo = state.program.getResolvedModule(sourceFile, declaration.name.text, mode);
+            if (resolvedModuleInfo && resolvedModuleInfo.resolvedModule) {
+                return state.program.getSourceFile(resolvedModuleInfo.resolvedModule.resolvedFileName);
+            }
+        }
+        if (declaration && typescript_1.default.isSourceFile(declaration)) {
+            return declaration;
+        }
+    }
+    if (typescript_1.default.isStringLiteralLike(moduleSpecifier)) {
+        const sourceFile = moduleSpecifier.getSourceFile();
+        const result = typescript_1.default.resolveModuleName(moduleSpecifier.text, sourceFile.path, state.compilerOptions, typescript_1.default.sys);
+        if (result.resolvedModule) {
+            return state.program.getSourceFile(result.resolvedModule.resolvedFileName);
+        }
+    }
+}
+//# sourceMappingURL=getSourceFileFromModuleSpecifier.js.map

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function getStatements(statement: ts.Statement): ReadonlyArray<ts.Statement>;

package/out/TSTransformer/util/getStatements.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.getStatements = getStatements;
+const typescript_1 = __importDefault(require("typescript"));
+function getStatements(statement) {
+    return typescript_1.default.isBlock(statement) ? statement.statements : [statement];
+}
+//# sourceMappingURL=getStatements.js.map

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function hasMultipleDefinitions(symbol: ts.Symbol, filter: (declaration: ts.Declaration) => boolean): boolean;

package/out/TSTransformer/util/hasMultipleDefinitions.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasMultipleDefinitions = hasMultipleDefinitions;
+function hasMultipleDefinitions(symbol, filter) {
+    var _a;
+    let amtValueDefinitions = 0;
+    for (const declaration of (_a = symbol.getDeclarations()) !== null && _a !== void 0 ? _a : []) {
+        if (filter(declaration)) {
+            amtValueDefinitions++;
+            if (amtValueDefinitions > 1) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=hasMultipleDefinitions.js.map

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

@@ -0,0 +1,3 @@
+import ts from "typescript";
+export declare function isReturnBlockedByTryStatement(node: ts.Node): boolean;
+export declare function isBreakBlockedByTryStatement(node: ts.Node): boolean;

package/out/TSTransformer/util/isBlockedByTryStatement.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isReturnBlockedByTryStatement = isReturnBlockedByTryStatement;
+exports.isBreakBlockedByTryStatement = isBreakBlockedByTryStatement;
+const typescript_1 = __importDefault(require("typescript"));
+function isReturnBlockedByTryStatement(node) {
+    const ancestor = typescript_1.default.findAncestor(node, ancestor => typescript_1.default.isTryStatement(ancestor) || typescript_1.default.isFunctionLikeDeclaration(ancestor));
+    return ancestor !== undefined && typescript_1.default.isTryStatement(ancestor);
+}
+function isBreakBlockedByTryStatement(node) {
+    const ancestor = typescript_1.default.findAncestor(node, ancestor => typescript_1.default.isTryStatement(ancestor) || typescript_1.default.isIterationStatement(ancestor, false) || typescript_1.default.isSwitchStatement(ancestor));
+    return ancestor !== undefined && typescript_1.default.isTryStatement(ancestor);
+}
+//# sourceMappingURL=isBlockedByTryStatement.js.map

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

@@ -0,0 +1,4 @@
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function isMethodFromType(state: TransformState, node: ts.Node, type: ts.Type): boolean;
+export declare function isMethod(state: TransformState, node: ts.PropertyAccessExpression | ts.ElementAccessExpression | ts.SignatureDeclarationBase | ts.PropertyName): boolean;

package/out/TSTransformer/util/isMethod.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isMethodFromType = isMethodFromType;
+exports.isMethod = isMethod;
+const diagnostics_1 = require("../../Shared/diagnostics");
+const getOrSetDefault_1 = require("../../Shared/util/getOrSetDefault");
+const DiagnosticService_1 = require("../classes/DiagnosticService");
+const traversal_1 = require("./traversal");
+const types_1 = require("./types");
+const typescript_1 = __importDefault(require("typescript"));
+function getThisParameter(parameters) {
+    const firstParam = parameters[0];
+    if (firstParam) {
+        const name = firstParam.name;
+        if (typescript_1.default.isIdentifier(name) && typescript_1.default.isThisIdentifier(name)) {
+            return name;
+        }
+    }
+}
+function isMethodDeclaration(state, node) {
+    if (typescript_1.default.isFunctionLike(node)) {
+        const thisParam = getThisParameter(node.parameters);
+        if (thisParam) {
+            return !(state.getType(thisParam).flags & typescript_1.default.TypeFlags.Void);
+        }
+        else {
+            if (typescript_1.default.isFunctionDeclaration(node)) {
+                return false;
+            }
+            if (typescript_1.default.isMethodDeclaration(node) || typescript_1.default.isMethodSignature(node)) {
+                return true;
+            }
+            if (typescript_1.default.isFunctionExpression(node)) {
+                const parent = (0, traversal_1.skipUpwards)(node).parent;
+                if (typescript_1.default.isPropertyAssignment(parent)) {
+                    const grandparent = (0, traversal_1.skipUpwards)(parent).parent;
+                    if (typescript_1.default.isObjectLiteralExpression(grandparent)) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+    }
+    return false;
+}
+function isMethodInner(state, node, type) {
+    var _a;
+    let hasMethodDefinition = false;
+    let hasCallbackDefinition = false;
+    for (const callSignature of type.getCallSignatures()) {
+        const thisValueDeclaration = (_a = callSignature.thisParameter) === null || _a === void 0 ? void 0 : _a.valueDeclaration;
+        if (thisValueDeclaration) {
+            if (!(state.getType(thisValueDeclaration).flags & typescript_1.default.TypeFlags.Void)) {
+                hasMethodDefinition = true;
+            }
+            else {
+                hasCallbackDefinition = true;
+            }
+        }
+        else if (callSignature.declaration) {
+            if (isMethodDeclaration(state, callSignature.declaration)) {
+                hasMethodDefinition = true;
+            }
+            else {
+                hasCallbackDefinition = true;
+            }
+        }
+    }
+    if (hasMethodDefinition && hasCallbackDefinition) {
+        DiagnosticService_1.DiagnosticService.addDiagnostic(diagnostics_1.errors.noMixedTypeCall(node));
+    }
+    return hasMethodDefinition;
+}
+function isMethodFromType(state, node, type) {
+    let result = false;
+    (0, types_1.walkTypes)(type, t => {
+        if (t.symbol) {
+            result || (result = (0, getOrSetDefault_1.getOrSetDefault)(state.multiTransformState.isMethodCache, t.symbol, () => isMethodInner(state, node, t)));
+        }
+    });
+    return result;
+}
+function isMethod(state, node) {
+    return isMethodFromType(state, node, state.getType(node));
+}
+//# sourceMappingURL=isMethod.js.map

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

@@ -0,0 +1,3 @@
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function isSymbolMutable(state: TransformState, idSymbol: ts.Symbol): boolean;

package/out/TSTransformer/util/isSymbolMutable.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.isSymbolMutable = isSymbolMutable;
+const getOrSetDefault_1 = require("../../Shared/util/getOrSetDefault");
+const traversal_1 = require("./traversal");
+const typescript_1 = __importDefault(require("typescript"));
+function isSymbolMutable(state, idSymbol) {
+    return (0, getOrSetDefault_1.getOrSetDefault)(state.multiTransformState.isDefinedAsLetCache, idSymbol, () => {
+        if (idSymbol.valueDeclaration) {
+            if (typescript_1.default.isParameter(idSymbol.valueDeclaration)) {
+                return true;
+            }
+            const varDecList = (0, traversal_1.getAncestor)(idSymbol.valueDeclaration, typescript_1.default.isVariableDeclarationList);
+            if (varDecList) {
+                return !!(varDecList.flags & typescript_1.default.NodeFlags.Let);
+            }
+        }
+        return false;
+    });
+}
+//# sourceMappingURL=isSymbolMutable.js.map

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function isSymbolOfValue(symbol: ts.Symbol): boolean;

package/out/TSTransformer/util/isSymbolOfValue.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.isSymbolOfValue = isSymbolOfValue;
+const typescript_1 = __importDefault(require("typescript"));
+function isSymbolOfValue(symbol) {
+    return !!(symbol.flags & typescript_1.default.SymbolFlags.Value) && !(symbol.flags & typescript_1.default.SymbolFlags.ConstEnum);
+}
+//# sourceMappingURL=isSymbolOfValue.js.map

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

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function isUsedAsStatement(expression: ts.Expression): boolean;

package/out/TSTransformer/util/isUsedAsStatement.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUsedAsStatement = isUsedAsStatement;
+const traversal_1 = require("./traversal");
+const typescript_1 = __importDefault(require("typescript"));
+function isUsedAsStatement(expression) {
+    const child = (0, traversal_1.skipUpwards)(expression);
+    const parent = child.parent;
+    if (typescript_1.default.isExpressionStatement(parent)) {
+        return true;
+    }
+    if (typescript_1.default.isForStatement(parent) && parent.condition !== child) {
+        return true;
+    }
+    if (typescript_1.default.isDeleteExpression(parent) && isUsedAsStatement(parent)) {
+        return true;
+    }
+    return false;
+}
+//# sourceMappingURL=isUsedAsStatement.js.map

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

@@ -0,0 +1,3 @@
+import { TransformState } from "..";
+import ts from "typescript";
+export declare function isValidMethodIndexWithoutCall(state: TransformState, node: ts.Node): boolean;

package/out/TSTransformer/util/isValidMethodIndexWithoutCall.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.isValidMethodIndexWithoutCall = isValidMethodIndexWithoutCall;
+const callMacros_1 = require("../macros/callMacros");
+const types_1 = require("./types");
+const typescript_1 = __importDefault(require("typescript"));
+function isValidMethodIndexWithoutCall(state, node) {
+    const { parent } = node;
+    if (typescript_1.default.isBinaryExpression(parent)) {
+        return true;
+    }
+    if (typescript_1.default.isPrefixUnaryExpression(parent)) {
+        return true;
+    }
+    if (typescript_1.default.isCallExpression(parent)) {
+        const expType = state.typeChecker.getNonOptionalType(state.getType(parent.expression));
+        const symbol = (0, types_1.getFirstDefinedSymbol)(state, expType);
+        if (symbol) {
+            const macro = state.services.macroManager.getCallMacro(symbol);
+            if (macro === callMacros_1.CALL_MACROS.typeIs ||
+                macro === callMacros_1.CALL_MACROS.typeOf) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=isValidMethodIndexWithoutCall.js.map

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

@@ -0,0 +1,2 @@
+import luau from "@roblox-ts/luau-ast";
+export declare function offset(expression: luau.Expression, value: number): luau.Expression<luau.SyntaxKind>;

package/out/TSTransformer/util/offset.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.offset = offset;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function getLiteralNumberValue(expression) {
+    if (luau_ast_1.default.isNumberLiteral(expression)) {
+        return Number(expression.value);
+    }
+    else if (luau_ast_1.default.isUnaryExpression(expression) && expression.operator === "-") {
+        const innerValue = getLiteralNumberValue(expression.expression);
+        if (innerValue !== undefined) {
+            return -innerValue;
+        }
+    }
+    return undefined;
+}
+function offset(expression, value) {
+    if (value === 0) {
+        return expression;
+    }
+    if (luau_ast_1.default.isBinaryExpression(expression) && (expression.operator === "+" || expression.operator === "-")) {
+        const rightValue = getLiteralNumberValue(expression.right);
+        if (rightValue !== undefined) {
+            const newRightValue = rightValue + value * (expression.operator === "-" ? -1 : 1);
+            if (newRightValue === 0) {
+                return expression.left;
+            }
+            else {
+                return luau_ast_1.default.binary(expression.left, expression.operator, luau_ast_1.default.number(newRightValue));
+            }
+        }
+    }
+    const literalValue = getLiteralNumberValue(expression);
+    if (literalValue !== undefined) {
+        return luau_ast_1.default.number(literalValue + value);
+    }
+    else {
+        return luau_ast_1.default.binary(expression, value > 0 ? "+" : "-", luau_ast_1.default.number(Math.abs(value)));
+    }
+}
+//# sourceMappingURL=offset.js.map

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

@@ -0,0 +1,13 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "..";
+export interface Pointer<T> {
+    name: string;
+    value: T;
+}
+export type MapPointer = Pointer<luau.Map | luau.TemporaryIdentifier>;
+export type ArrayPointer = Pointer<luau.Array | luau.TemporaryIdentifier>;
+export declare function createMapPointer(name: string): MapPointer;
+export declare function createArrayPointer(name: string): ArrayPointer;
+export declare function assignToMapPointer(state: TransformState, ptr: Pointer<luau.Map | luau.AnyIdentifier>, left: luau.Expression, right: luau.Expression): void;
+export declare function disableMapInline(state: TransformState, ptr: MapPointer): asserts ptr is Pointer<luau.TemporaryIdentifier>;
+export declare function disableArrayInline(state: TransformState, ptr: ArrayPointer): asserts ptr is Pointer<luau.TemporaryIdentifier>;

package/out/TSTransformer/util/pointer.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.createMapPointer = createMapPointer;
+exports.createArrayPointer = createArrayPointer;
+exports.assignToMapPointer = assignToMapPointer;
+exports.disableMapInline = disableMapInline;
+exports.disableArrayInline = disableArrayInline;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function createMapPointer(name) {
+    return { name, value: luau_ast_1.default.map() };
+}
+function createArrayPointer(name) {
+    return { name, value: luau_ast_1.default.array() };
+}
+function assignToMapPointer(state, ptr, left, right) {
+    if (luau_ast_1.default.isMap(ptr.value)) {
+        luau_ast_1.default.list.push(ptr.value.fields, luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.MapField, {
+            index: left,
+            value: right,
+        }));
+    }
+    else {
+        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: ptr.value,
+                index: left,
+            }),
+            operator: "=",
+            right,
+        }));
+    }
+}
+function disableMapInline(state, ptr) {
+    if (luau_ast_1.default.isMap(ptr.value)) {
+        ptr.value = state.pushToVar(ptr.value, ptr.name);
+    }
+}
+function disableArrayInline(state, ptr) {
+    if (luau_ast_1.default.isArray(ptr.value)) {
+        ptr.value = state.pushToVar(ptr.value, ptr.name);
+    }
+}
+//# sourceMappingURL=pointer.js.map

package/out/TSTransformer/util/spreadDestructuring/index.d.ts

@@ -0,0 +1,9 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../../classes/TransformState";
+import ts from "typescript";
+export * from "./spreadDestructureArray";
+export * from "./spreadDestructureMap";
+export * from "./spreadDestructureObject";
+export * from "./spreadDestructureSet";
+type SpreadDestructor = (state: TransformState, parentId: luau.AnyIdentifier, index: number, idStack: Array<luau.AnyIdentifier>) => luau.Expression;
+export declare function getSpreadDestructorForType(state: TransformState, node: ts.Node, type: ts.Type): SpreadDestructor;

package/out/TSTransformer/util/spreadDestructuring/index.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpreadDestructorForType = getSpreadDestructorForType;
+const assert_1 = require("../../../Shared/util/assert");
+const spreadDestructureArray_1 = require("./spreadDestructureArray");
+const spreadDestructureGenerator_1 = require("./spreadDestructureGenerator");
+const spreadDestructureMap_1 = require("./spreadDestructureMap");
+const spreadDestructureSet_1 = require("./spreadDestructureSet");
+const types_1 = require("../types");
+__exportStar(require("./spreadDestructureArray"), exports);
+__exportStar(require("./spreadDestructureMap"), exports);
+__exportStar(require("./spreadDestructureObject"), exports);
+__exportStar(require("./spreadDestructureSet"), exports);
+function getSpreadDestructorForType(state, node, type) {
+    if ((0, types_1.isDefinitelyType)(type, (0, types_1.isArrayType)(state))) {
+        return spreadDestructureArray_1.spreadDestructureArray;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isSetType)(state))) {
+        return spreadDestructureSet_1.spreadDestructureSet;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isMapType)(state))) {
+        return spreadDestructureMap_1.spreadDestructureMap;
+    }
+    else if ((0, types_1.isDefinitelyType)(type, (0, types_1.isGeneratorType)(state))) {
+        return spreadDestructureGenerator_1.spreadDestructureGenerator;
+    }
+    return () => {
+        (0, assert_1.assert)(false, "Spread Destructuring not supported for type: " + state.typeChecker.typeToString(type));
+    };
+}
+//# sourceMappingURL=index.js.map

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureArray.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../../classes/TransformState";
+export declare function spreadDestructureArray(state: TransformState, parentId: luau.AnyIdentifier, index: number): luau.CallExpression;

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureArray.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spreadDestructureArray = spreadDestructureArray;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function spreadDestructureArray(state, parentId, index) {
+    return luau_ast_1.default.call(luau_ast_1.default.globals.table.move, [
+        parentId,
+        luau_ast_1.default.number(index + 1),
+        luau_ast_1.default.unary("#", parentId),
+        luau_ast_1.default.number(1),
+        luau_ast_1.default.array(),
+    ]);
+}
+//# sourceMappingURL=spreadDestructureArray.js.map

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureGenerator.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../../classes/TransformState";
+export declare function spreadDestructureGenerator(state: TransformState, parentId: luau.AnyIdentifier): luau.TemporaryIdentifier;

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureGenerator.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.spreadDestructureGenerator = spreadDestructureGenerator;
+const luau_ast_1 = __importDefault(require("@roblox-ts/luau-ast"));
+function spreadDestructureGenerator(state, parentId) {
+    const restId = state.pushToVar(luau_ast_1.default.array(), "rest");
+    const valueId = luau_ast_1.default.tempId("v");
+    const variable = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.VariableDeclaration, {
+        left: valueId,
+        right: luau_ast_1.default.call(luau_ast_1.default.property(parentId, "next")),
+    });
+    const doneCheck = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.IfStatement, {
+        condition: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BinaryExpression, {
+            left: luau_ast_1.default.property(valueId, "done"),
+            operator: "==",
+            right: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.TrueLiteral, {}),
+        }),
+        elseBody: luau_ast_1.default.list.make(),
+        statements: luau_ast_1.default.list.make(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.BreakStatement, {})),
+    });
+    const pushToRest = luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.CallStatement, {
+        expression: luau_ast_1.default.call(luau_ast_1.default.globals.table.insert, [restId, luau_ast_1.default.property(valueId, "value")]),
+    });
+    state.prereq(luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.WhileStatement, {
+        condition: luau_ast_1.default.create(luau_ast_1.default.SyntaxKind.TrueLiteral, {}),
+        statements: luau_ast_1.default.list.make(variable, doneCheck, pushToRest),
+    }));
+    return restId;
+}
+//# sourceMappingURL=spreadDestructureGenerator.js.map

package/out/TSTransformer/util/spreadDestructuring/spreadDestructureMap.d.ts

@@ -0,0 +1,3 @@
+import luau from "@roblox-ts/luau-ast";
+import { TransformState } from "../../classes/TransformState";
+export declare function spreadDestructureMap(state: TransformState, parentId: luau.AnyIdentifier, index: number, idStack: Array<luau.AnyIdentifier>): luau.TemporaryIdentifier;