@flamework-experimental/transformer 2.0.0-alpha.0

package/out/classes/transformState.js

@@ -0,0 +1,623 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformState = void 0;
+var typescript_1 = __importDefault(require("typescript"));
+var fs_1 = __importDefault(require("fs"));
+var crypto_1 = __importDefault(require("crypto"));
+var path_1 = __importDefault(require("path"));
+var hashids_1 = __importDefault(require("hashids"));
+var transformNode_1 = require("../transformations/transformNode");
+var cache_1 = require("../util/cache");
+var getPackageJson_1 = require("../util/functions/getPackageJson");
+var buildInfo_1 = require("./buildInfo");
+var logger_1 = require("./logger");
+var factory_1 = require("../util/factory");
+var isPathDescendantOf_1 = require("../util/functions/isPathDescendantOf");
+var isCleanBuildDirectory_1 = require("../util/functions/isCleanBuildDirectory");
+var parseCommandLine_1 = require("../util/functions/parseCommandLine");
+var createPathTranslator_1 = require("../util/functions/createPathTranslator");
+var arePathsEqual_1 = require("../util/functions/arePathsEqual");
+var nodeMetadata_1 = require("./nodeMetadata");
+var rojo_resolver_1 = require("@roblox-ts/rojo-resolver");
+var assert_1 = require("../util/functions/assert");
+var shuffle_1 = require("../util/functions/shuffle");
+var glob_1 = __importDefault(require("glob"));
+var pluginHost_1 = require("../transformations/plugins/pluginHost");
+var tryResolve_1 = require("../util/functions/tryResolve");
+var projectConfig_1 = require("../util/projectConfig");
+var diagnostics_1 = require("./diagnostics");
+var packages_1 = require("../util/packages");
+var TransformState = /** @class */ (function () {
+    function TransformState(program, context, inlineConfig) {
+        var _a, _b, _c, _d, _e, _f;
+        var _g, _h;
+        this.program = program;
+        this.context = context;
+        this.parsedCommandLine = (0, parseCommandLine_1.parseCommandLine)();
+        this.currentDirectory = this.parsedCommandLine.project;
+        this.options = this.program.getCompilerOptions();
+        this.srcDir = (_a = this.options.rootDir) !== null && _a !== void 0 ? _a : this.currentDirectory;
+        this.outDir = (_b = this.options.outDir) !== null && _b !== void 0 ? _b : this.currentDirectory;
+        this.rootDirs = this.options.rootDirs ? this.options.rootDirs : [this.srcDir];
+        this.typeChecker = this.program.getTypeChecker();
+        this.isUserMacroCache = new Map();
+        this.nextRootStatements = new Array();
+        /**
+         * Whether this process started from the previous build's `flamework.build` rather than a fresh
+         * one, which an incremental build does so that the files it does not recompile keep their ids.
+         * Under obfuscation that also keeps the ids a release was meant to rotate.
+         */
+        this.buildInfoReused = false;
+        this.fileImports = new Map();
+        this.prereqStack = new Array();
+        var _j = (0, getPackageJson_1.getPackageJson)(this.currentDirectory), packageJson = _j.result, directory = _j.directory;
+        this.rootDirectory = directory;
+        (0, assert_1.assert)(packageJson.name);
+        // Read once per process: a watcher keeps the config and environment it started with, since
+        // only the files that changed are recompiled and the rest would disagree with them. Every
+        // later compilation reads again only to notice a change and ask for a restart.
+        var loaded = (0, projectConfig_1.loadProjectConfig)(this.currentDirectory, this.rootDirectory, inlineConfig);
+        var fingerprint = (0, projectConfig_1.fingerprintProjectConfig)(loaded);
+        if (cache_1.Cache.projectConfig === undefined) {
+            cache_1.Cache.projectConfig = loaded;
+            cache_1.Cache.projectConfigFingerprint = fingerprint;
+        }
+        else if (cache_1.Cache.projectConfigFingerprint !== fingerprint) {
+            logger_1.Logger.warn("flamework.config.json or .env changed since the watcher started", "The values it started with are still in use; restart the watcher to apply the change.");
+        }
+        var effective = cache_1.Cache.projectConfig;
+        this.config = __assign({}, effective.config);
+        this.configPath = effective.configPath;
+        this.projectConfig = effective.project;
+        this.env = effective.env;
+        this.setupRojo();
+        this.setupBuildInfo();
+        (_c = (_g = this.config).idGenerationMode) !== null && _c !== void 0 ? _c : (_g.idGenerationMode = this.config.obfuscation ? "obfuscated" : "full");
+        var previousMode = this.buildInfo.setIdGenerationMode(this.config.idGenerationMode);
+        if (previousMode !== undefined) {
+            logger_1.Logger.info("idGenerationMode changed from '".concat(previousMode, "' to '").concat(this.config.idGenerationMode, "'; every identifier is regenerated"));
+        }
+        // Obfuscation is only worth something if a release's ids differ from the last release's.
+        // A plain build recreates flamework.build, and with it the salt and the build seed, so
+        // that holds on its own; these are the two ways of undoing it.
+        if (this.config.obfuscation && cache_1.Cache.isInitialCompile) {
+            if (this.config.salt !== undefined) {
+                logger_1.Logger.warn("transformer.salt is set with obfuscation on", "A fixed salt gives every build the same obfuscated ids; leave it unset so each build gets fresh ones.");
+            }
+            if (this.buildInfoReused) {
+                logger_1.Logger.warn("obfuscated ids were kept from the previous build", "This is an incremental build, so files that do not recompile keep their ids and the rest have to match.", "Delete ".concat((_d = this.options.tsBuildInfoFile) !== null && _d !== void 0 ? _d : "the tsbuildinfo", " before a release build to rotate every id."));
+            }
+        }
+        this.packageName = packageJson.name;
+        this.isGame = !this.packageName.startsWith("@");
+        this.includeDirectory = this.getIncludePath();
+        if (!this.isGame)
+            (_e = (_h = this.config).hashPrefix) !== null && _e !== void 0 ? _e : (_h.hashPrefix = this.packageName);
+        this.buildInfo.setIdentifierPrefix(this.config.hashPrefix);
+        if (((_f = this.config.hashPrefix) === null || _f === void 0 ? void 0 : _f.startsWith("$")) && !this.packageName.startsWith(packages_1.FLAMEWORK_SCOPE)) {
+            throw new Error("The hashPrefix $ is used internally by Flamework");
+        }
+        cache_1.Cache.isInitialCompile = false;
+        this.pluginHost = (0, pluginHost_1.createPluginHost)(this);
+    }
+    TransformState.prototype.setupBuildInfo = function () {
+        var e_1, _a, e_2, _b;
+        var _c;
+        var baseBuildInfo = buildInfo_1.BuildInfo.fromDirectory(this.currentDirectory);
+        if (!baseBuildInfo || (cache_1.Cache.isInitialCompile && (0, isCleanBuildDirectory_1.isCleanBuildDirectory)(this.options))) {
+            if (this.options.incremental && this.options.tsBuildInfoFile) {
+                if (typescript_1.default.sys.fileExists(this.options.tsBuildInfoFile)) {
+                    throw new Error("Flamework cannot be built in a dirty environment, please delete your tsbuildinfo");
+                }
+            }
+            baseBuildInfo = new buildInfo_1.BuildInfo(path_1.default.join(this.currentDirectory, "flamework.build"));
+        }
+        else if (cache_1.Cache.isInitialCompile) {
+            this.buildInfoReused = true;
+        }
+        this.buildInfo = baseBuildInfo;
+        var candidates = (_c = cache_1.Cache.buildInfoCandidates) !== null && _c !== void 0 ? _c : [];
+        if (!cache_1.Cache.buildInfoCandidates) {
+            cache_1.Cache.buildInfoCandidates = candidates;
+            var candidatesSet = new Set();
+            try {
+                for (var _d = __values(this.program.getSourceFiles()), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var file = _e.value;
+                    var buildCandidate = buildInfo_1.BuildInfo.findCandidateUpper(path_1.default.dirname(file.fileName));
+                    if (buildCandidate &&
+                        !(0, arePathsEqual_1.arePathsEqual)(buildCandidate, baseBuildInfo.buildInfoPath) &&
+                        !candidatesSet.has(buildCandidate)) {
+                        candidatesSet.add(buildCandidate);
+                        candidates.push(buildCandidate);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        }
+        try {
+            for (var candidates_1 = __values(candidates), candidates_1_1 = candidates_1.next(); !candidates_1_1.done; candidates_1_1 = candidates_1.next()) {
+                var candidate = candidates_1_1.value;
+                var relativeCandidate = path_1.default.relative(this.currentDirectory, candidate);
+                var buildInfo = buildInfo_1.BuildInfo.fromPath(candidate);
+                if (buildInfo) {
+                    logger_1.Logger.infoIfVerbose("Loaded buildInfo at ".concat(relativeCandidate, ", next id: ").concat(buildInfo.getLatestId()));
+                    baseBuildInfo.addBuildInfo(buildInfo);
+                }
+                else {
+                    logger_1.Logger.warn("Build info not valid at ".concat(relativeCandidate));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (candidates_1_1 && !candidates_1_1.done && (_b = candidates_1.return)) _b.call(candidates_1);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+    };
+    TransformState.prototype.setupRojo = function () {
+        this.pathTranslator = (0, createPathTranslator_1.createPathTranslator)(this.program);
+        var rojoArgvIndex = process.argv.findIndex(function (v) { return v === "--rojo"; });
+        var rojoArg = rojoArgvIndex !== -1 ? process.argv[rojoArgvIndex + 1] : undefined;
+        var rojoConfig;
+        if (rojoArg && rojoArg !== "") {
+            rojoConfig = path_1.default.resolve(rojoArg);
+        }
+        else {
+            rojoConfig = rojo_resolver_1.RojoResolver.findRojoConfigFilePath(this.currentDirectory).path;
+        }
+        if (rojoConfig !== undefined) {
+            var rojoContents = fs_1.default.readFileSync(rojoConfig, { encoding: "ascii" });
+            var sum = crypto_1.default.createHash("md5").update(rojoContents).digest("hex");
+            if (sum === cache_1.Cache.rojoSum) {
+                this.rojoResolver = cache_1.Cache.rojoResolver;
+            }
+            else {
+                this.rojoResolver = rojo_resolver_1.RojoResolver.fromPath(rojoConfig);
+                cache_1.Cache.rojoSum = sum;
+                cache_1.Cache.rojoResolver = this.rojoResolver;
+            }
+        }
+    };
+    TransformState.prototype.getIncludePath = function () {
+        var includeArgvIndex = process.argv.findIndex(function (v) { return v === "--i" || v === "--includePath"; });
+        var includePath = includeArgvIndex !== -1 ? process.argv[includeArgvIndex + 1] : undefined;
+        return path_1.default.resolve(includePath || path_1.default.join(this.rootDirectory, "include"));
+    };
+    /**
+     * Since npm modules can be symlinked, TypeScript can resolve them to their real path (outside of the project directory.)
+     *
+     * This function attempts to convert the real path of *npm modules* back to their path inside the project directory.
+     * This is required to have RojoResolver be able to resolve files.
+     */
+    TransformState.prototype.toModulePath = function (filePath) {
+        // The module is under our root directory, so it's probably not symlinked.
+        if ((0, isPathDescendantOf_1.isPathDescendantOf)(filePath, this.rootDirectory)) {
+            return filePath;
+        }
+        var packageJsonPath = typescript_1.default.findPackageJson(filePath, typescript_1.default.sys);
+        if (!packageJsonPath) {
+            throw new Error("Unable to convert '".concat(filePath, "' to module."));
+        }
+        var packageJson = JSON.parse(fs_1.default.readFileSync(packageJsonPath, { encoding: "utf8" }));
+        return path_1.default.join(this.rootDirectory, "node_modules", packageJson.name, path_1.default.relative(path_1.default.dirname(packageJsonPath), filePath));
+    };
+    TransformState.prototype.calculateGlobs = function (globs) {
+        var _this = this;
+        if (!globs) {
+            return;
+        }
+        for (var pathGlob in globs) {
+            var paths = glob_1.default.sync(pathGlob, {
+                root: this.rootDirectory,
+                cwd: this.rootDirectory,
+                nocase: true,
+            });
+            globs[pathGlob] = paths.map(function (globPath) {
+                var outputPath = _this.pathTranslator.getOutputPath(globPath);
+                return path_1.default.relative(_this.rootDirectory, outputPath).replace(/\\/g, "/");
+            });
+        }
+    };
+    TransformState.prototype.convertGlobs = function (globs, luaOut, pkg) {
+        var e_3, _a;
+        var _b;
+        if (!globs) {
+            return;
+        }
+        var pkgInfo = pkg ? this.buildInfo.getBuildInfoFromPrefix(pkg) : undefined;
+        var root = pkgInfo ? path_1.default.dirname(this.toModulePath(pkgInfo.buildInfoPath)) : this.rootDirectory;
+        for (var pathGlob in globs) {
+            var paths = globs[pathGlob];
+            var rbxPaths = new Array();
+            try {
+                for (var paths_1 = (e_3 = void 0, __values(paths)), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
+                    var globPath = paths_1_1.value;
+                    var rbxPath = (_b = this.rojoResolver) === null || _b === void 0 ? void 0 : _b.getRbxPathFromFilePath(path_1.default.join(root, globPath));
+                    if (rbxPath) {
+                        rbxPaths.push(rbxPath);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (paths_1_1 && !paths_1_1.done && (_a = paths_1.return)) _a.call(paths_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            luaOut.set(pkgInfo ? pathGlob : this.obfuscateText(pathGlob, "addPaths"), rbxPaths);
+        }
+    };
+    TransformState.prototype.getFileId = function (file) {
+        return path_1.default.relative(this.rootDirectory, file.fileName).replace(/\\/g, "/");
+    };
+    TransformState.prototype.saveArtifacts = function () {
+        var e_4, _a, e_5, _b;
+        var _c, _d, _e, _f;
+        var start = new Date().getTime();
+        this.calculateGlobs((_c = this.buildInfo.getMetadata("globs")) === null || _c === void 0 ? void 0 : _c.paths);
+        if (this.isGame) {
+            var writtenFiles = new Map();
+            var files = ["globs.json", "config.json", "paths.json"];
+            // The runtime sections of flamework.config.json, for the packages to read at runtime.
+            var runtimeConfig = (0, projectConfig_1.getRuntimeConfig)(this.projectConfig);
+            if (runtimeConfig) {
+                // `testing.entry` is a source path in the file; the runner's cloud module needs the
+                // ModuleScript, so it is written as a tree path, resolved the way a path macro is.
+                var entry = (_d = runtimeConfig.testing) === null || _d === void 0 ? void 0 : _d.entry;
+                if (entry !== undefined) {
+                    var sourcePath = entry.endsWith(".ts") ? entry : "".concat(entry, ".ts");
+                    var outputPath = this.pathTranslator.getOutputPath(sourcePath);
+                    var rbxPath = (_e = this.rojoResolver) === null || _e === void 0 ? void 0 : _e.getRbxPathFromFilePath(outputPath);
+                    if (rbxPath === undefined) {
+                        throw new Error("flamework.config.json: testing.entry '".concat(entry, "' is not in the Rojo tree; give the source path of the ModuleScript that exports ignite(), for example \"src/server/main\""));
+                    }
+                    runtimeConfig.testing = __assign(__assign({}, runtimeConfig.testing), { entry: rbxPath });
+                }
+                writtenFiles.set("config.json", JSON.stringify(runtimeConfig));
+            }
+            // Paths are emitted relative to the Rojo tree's root, which is `game` in a place but the
+            // model's own root in a plugin. The runtime finds that root by climbing from the include
+            // folder, so this records how far below the root the include folder sits.
+            var includeRbxPath = (_f = this.rojoResolver) === null || _f === void 0 ? void 0 : _f.getRbxPathFromFilePath(this.includeDirectory);
+            if (includeRbxPath !== undefined) {
+                writtenFiles.set("paths.json", JSON.stringify({ includeDepth: includeRbxPath.length }));
+            }
+            var packageGlobs = this.buildInfo.getChildrenMetadata("globs");
+            var globs = this.buildInfo.getMetadata("globs");
+            if (globs || packageGlobs.size > 0) {
+                var transformedGlobs = new Map();
+                this.convertGlobs(globs === null || globs === void 0 ? void 0 : globs.paths, transformedGlobs);
+                var transformedPackageGlobs = new Map();
+                try {
+                    for (var packageGlobs_1 = __values(packageGlobs), packageGlobs_1_1 = packageGlobs_1.next(); !packageGlobs_1_1.done; packageGlobs_1_1 = packageGlobs_1.next()) {
+                        var _g = __read(packageGlobs_1_1.value, 2), pkg = _g[0], packageGlob = _g[1];
+                        var transformedGlobs_1 = new Map();
+                        this.convertGlobs(packageGlob === null || packageGlob === void 0 ? void 0 : packageGlob.paths, transformedGlobs_1, pkg);
+                        transformedPackageGlobs.set(pkg, Object.fromEntries(transformedGlobs_1));
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (packageGlobs_1_1 && !packageGlobs_1_1.done && (_a = packageGlobs_1.return)) _a.call(packageGlobs_1);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                writtenFiles.set("globs.json", JSON.stringify({
+                    game: Object.fromEntries(transformedGlobs),
+                    packages: Object.fromEntries(transformedPackageGlobs),
+                }));
+            }
+            var metadataPath = path_1.default.join(this.includeDirectory, "flamework");
+            var metadataExists = fs_1.default.existsSync(metadataPath);
+            if (!metadataExists && writtenFiles.size > 0) {
+                fs_1.default.mkdirSync(metadataPath);
+            }
+            try {
+                for (var files_1 = __values(files), files_1_1 = files_1.next(); !files_1_1.done; files_1_1 = files_1.next()) {
+                    var file = files_1_1.value;
+                    var filePath = path_1.default.join(metadataPath, file);
+                    var contents = writtenFiles.get(file);
+                    if (contents) {
+                        fs_1.default.writeFileSync(filePath, contents);
+                    }
+                    else if (fs_1.default.existsSync(filePath)) {
+                        fs_1.default.rmSync(filePath);
+                    }
+                }
+            }
+            catch (e_5_1) { e_5 = { error: e_5_1 }; }
+            finally {
+                try {
+                    if (files_1_1 && !files_1_1.done && (_b = files_1.return)) _b.call(files_1);
+                }
+                finally { if (e_5) throw e_5.error; }
+            }
+            if (metadataExists && writtenFiles.size === 0) {
+                fs_1.default.rmdirSync(metadataPath);
+            }
+        }
+        this.buildInfo.save();
+        if (logger_1.Logger.verbose) {
+            // Watch mode includes an extra newline when compilation finishes,
+            // so we remove that newline before Flamework's message.
+            var watch = process.argv.includes("-w") || process.argv.includes("--watch");
+            if (watch) {
+                process.stdout.write("\x1b[A\x1b[K");
+            }
+            logger_1.Logger.info("Flamework artifacts finished in ".concat(new Date().getTime() - start, "ms"));
+            if (watch) {
+                process.stdout.write("\n");
+            }
+        }
+    };
+    TransformState.prototype.isUserMacro = function (symbol) {
+        var e_6, _a;
+        var cached = this.isUserMacroCache.get(symbol);
+        if (cached !== undefined)
+            return cached;
+        if (symbol.declarations) {
+            try {
+                for (var _b = __values(symbol.declarations), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var declaration = _c.value;
+                    var metadata = nodeMetadata_1.NodeMetadata.fromCache(this, declaration);
+                    if (metadata.isRequested("macro")) {
+                        this.isUserMacroCache.set(symbol, true);
+                        return true;
+                    }
+                }
+            }
+            catch (e_6_1) { e_6 = { error: e_6_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_6) throw e_6.error; }
+            }
+        }
+        this.isUserMacroCache.set(symbol, false);
+        return false;
+    };
+    TransformState.prototype.addFileImport = function (file, importPath, name) {
+        var e_7, _a, e_8, _b;
+        var _c;
+        // Flamework itself uses features which require imports, this will rewrite those imports to be valid inside the Flamework package.
+        if (importPath === packages_1.CORE_PACKAGE && this.packageName === packages_1.CORE_PACKAGE && name === "Reflect") {
+            var modulePath = path_1.default.join(this.rootDirectory, "src", "reflect");
+            importPath = "./" + path_1.default.relative(path_1.default.dirname(file.fileName), modulePath) || ".";
+        }
+        var importInfos = this.fileImports.get(file.fileName);
+        if (!importInfos)
+            this.fileImports.set(file.fileName, (importInfos = []));
+        var importInfo = importInfos.find(function (x) { return x.path === importPath; });
+        if (!importInfo)
+            importInfos.push((importInfo = { path: importPath, entries: [] }));
+        var identifier = (_c = importInfo.entries.find(function (x) { return x.name === name; })) === null || _c === void 0 ? void 0 : _c.identifier;
+        if (!identifier) {
+            try {
+                start: for (var _d = __values(file.statements), _e = _d.next(); !_e.done; _e = _d.next()) {
+                    var statement = _e.value;
+                    if (!factory_1.f.is.importDeclaration(statement))
+                        break;
+                    if (!factory_1.f.is.string(statement.moduleSpecifier))
+                        continue;
+                    if (!factory_1.f.is.importClauseDeclaration(statement.importClause))
+                        continue;
+                    if (!factory_1.f.is.namedImports(statement.importClause.namedBindings))
+                        continue;
+                    if (statement.importClause.isTypeOnly)
+                        continue;
+                    if (statement.moduleSpecifier.text !== importPath)
+                        continue;
+                    try {
+                        for (var _f = (e_8 = void 0, __values(statement.importClause.namedBindings.elements)), _g = _f.next(); !_g.done; _g = _f.next()) {
+                            var importElement = _g.value;
+                            if (importElement.isTypeOnly) {
+                                continue;
+                            }
+                            if (importElement.propertyName) {
+                                if (importElement.propertyName.text === name) {
+                                    identifier = importElement.name;
+                                    break start;
+                                }
+                            }
+                            else {
+                                if (importElement.name.text === name) {
+                                    identifier = importElement.name;
+                                    break start;
+                                }
+                            }
+                        }
+                    }
+                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+                    finally {
+                        try {
+                            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+                        }
+                        finally { if (e_8) throw e_8.error; }
+                    }
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_a = _d.return)) _a.call(_d);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+        if (!identifier) {
+            importInfo.entries.push({ name: name, identifier: (identifier = factory_1.f.identifier(name, true)) });
+        }
+        return identifier;
+    };
+    TransformState.prototype.getSourceFile = function (node) {
+        var parseNode = typescript_1.default.getParseTreeNode(node);
+        if (!parseNode)
+            throw new Error("Could not find parse tree node");
+        return typescript_1.default.getSourceFileOfNode(parseNode);
+    };
+    TransformState.prototype.getSymbol = function (node, followAlias) {
+        if (followAlias === void 0) { followAlias = true; }
+        if (factory_1.f.is.namedDeclaration(node)) {
+            return this.getSymbol(node.name);
+        }
+        var symbol = this.typeChecker.getSymbolAtLocation(node);
+        if (symbol && followAlias) {
+            return typescript_1.default.skipAlias(symbol, this.typeChecker);
+        }
+        else {
+            return symbol;
+        }
+    };
+    TransformState.prototype.hash = function (id, noPrefix) {
+        var _a;
+        var hashPrefix = this.config.hashPrefix;
+        var salt = (_a = this.config.salt) !== null && _a !== void 0 ? _a : this.buildInfo.getSalt();
+        var hashGenerator = new hashids_1.default(salt, 2);
+        if ((this.isGame && !hashPrefix) || noPrefix) {
+            return "".concat(hashGenerator.encode(id));
+        }
+        else {
+            // If the package name is namespaced, then it can be used in
+            // other projects so we want to add a prefix to the Id to prevent
+            // collisions with other packages or the game.
+            return "".concat(hashPrefix !== null && hashPrefix !== void 0 ? hashPrefix : this.packageName, ":").concat(hashGenerator.encode(id));
+        }
+    };
+    TransformState.prototype.obfuscateText = function (text, context) {
+        return this.config.obfuscation ? this.buildInfo.hashString(text, context) : text;
+    };
+    TransformState.prototype.obfuscateArray = function (array) {
+        return this.config.obfuscation ? (0, shuffle_1.shuffle)(array) : array;
+    };
+    TransformState.prototype.addDiagnostic = function (diag) {
+        this.context.addDiagnostic(diag);
+    };
+    TransformState.prototype.capture = function (cb) {
+        this.prereqStack.push([]);
+        var result = cb();
+        return [result, this.prereqStack.pop()];
+    };
+    TransformState.prototype.prereq = function (statement) {
+        var stack = this.prereqStack[this.prereqStack.length - 1];
+        if (stack)
+            stack.push(statement);
+    };
+    TransformState.prototype.prereqList = function (statements) {
+        var stack = this.prereqStack[this.prereqStack.length - 1];
+        if (stack)
+            stack.push.apply(stack, __spreadArray([], __read(statements), false));
+    };
+    TransformState.prototype.isCapturing = function (threshold) {
+        if (threshold === void 0) { threshold = 1; }
+        return this.prereqStack.length > threshold;
+    };
+    TransformState.prototype.transform = function (node) {
+        var _this = this;
+        return typescript_1.default.visitEachChild(node, function (newNode) { return (0, transformNode_1.transformNode)(_this, newNode); }, this.context);
+    };
+    TransformState.prototype.transformNode = function (node) {
+        var _this = this;
+        // Technically this isn't guaranteed to return `T`, and TypeScript 5.0+ updated the signature to disallow this,
+        // but we don't care so we'll just cast it.
+        return typescript_1.default.visitNode(node, function (newNode) { return (0, transformNode_1.transformNode)(_this, newNode); });
+    };
+    /**
+     * Returns the identifier to reach `t` from, for generated guards.
+     *
+     * Generated guards use functions such as `t.unionList` that older `@rbxts/t` releases lack. When
+     * the project resolves a different `@rbxts/t` than `@flamework-experimental/core` does, `t` is imported through
+     * core's prelude so that the guards run against the version core was built with.
+     */
+    TransformState.prototype.getGuardLibrary = function (file) {
+        if (this.flameworkGuardLibraryPath) {
+            return this.addFileImport(file, this.flameworkGuardLibraryPath, "t");
+        }
+        // Inside the Flamework packages themselves there is nothing to reconcile.
+        if (this.packageName.startsWith("".concat(packages_1.FLAMEWORK_SCOPE, "/"))) {
+            this.flameworkGuardLibraryPath = "@rbxts/t";
+            return this.addFileImport(file, "@rbxts/t", "t");
+        }
+        var corePath = (0, tryResolve_1.tryResolveTS)(this, packages_1.CORE_PACKAGE, file.fileName);
+        if (corePath === undefined) {
+            diagnostics_1.Diagnostics.warning(file.endOfFileToken, "Flamework core was not found, guard generation may not work.");
+            return this.addFileImport(file, "@rbxts/t", "t");
+        }
+        var fileGuardPath = (0, tryResolve_1.tryResolveTS)(this, "@rbxts/t", file.fileName);
+        var coreGuardPath = (0, tryResolve_1.tryResolveTS)(this, "@rbxts/t", corePath);
+        if (fileGuardPath === coreGuardPath) {
+            // @flamework-experimental/core and the consuming project are using the same @rbxts/t version.
+            this.flameworkGuardLibraryPath = "@rbxts/t";
+            return this.addFileImport(file, "@rbxts/t", "t");
+        }
+        if (coreGuardPath === undefined ||
+            !(0, isPathDescendantOf_1.isPathDescendantOf)(coreGuardPath, path_1.default.join(path_1.default.dirname(corePath), "../node_modules/@rbxts/t"))) {
+            diagnostics_1.Diagnostics.warning(file.endOfFileToken, "Valid `@rbxts/t` was not found, guard generation may not work.");
+            return this.addFileImport(file, "@rbxts/t", "t");
+        }
+        this.flameworkGuardLibraryPath = "".concat(packages_1.CORE_PACKAGE, "/out/prelude");
+        return this.addFileImport(file, this.flameworkGuardLibraryPath, "t");
+    };
+    return TransformState;
+}());
+exports.TransformState = TransformState;