@jackctaylor/roblox-ts 3.0.0-projectrefs.0

package/out/Shared/diagnostics.d.ts

@@ -0,0 +1,79 @@
+import { RbxPath } from "@roblox-ts/rojo-resolver";
+import { SourceFileWithTextRange } from "./types";
+import ts from "typescript";
+export type DiagnosticFactory<T extends Array<unknown> = []> = {
+    (node: ts.Node | SourceFileWithTextRange, ...context: T): ts.DiagnosticWithLocation;
+    id: number;
+};
+export declare function getDiagnosticId(diagnostic: ts.Diagnostic): number;
+export declare const errors: {
+    noInvalidIdentifier: DiagnosticFactory<[]>;
+    noReservedIdentifier: DiagnosticFactory<[]>;
+    noReservedClassFields: DiagnosticFactory<[]>;
+    noClassMetamethods: DiagnosticFactory<[]>;
+    noForInStatement: DiagnosticFactory<[]>;
+    noLabeledStatement: DiagnosticFactory<[]>;
+    noDebuggerStatement: DiagnosticFactory<[]>;
+    noNullLiteral: DiagnosticFactory<[]>;
+    noPrivateIdentifier: DiagnosticFactory<[]>;
+    noTypeOfExpression: DiagnosticFactory<[]>;
+    noRegex: DiagnosticFactory<[]>;
+    noBigInt: DiagnosticFactory<[]>;
+    noAny: DiagnosticFactory<[]>;
+    noVar: DiagnosticFactory<[]>;
+    noGetterSetter: DiagnosticFactory<[]>;
+    noAutoAccessorModifiers: DiagnosticFactory<[]>;
+    noEqualsEquals: DiagnosticFactory<[]>;
+    noExclamationEquals: DiagnosticFactory<[]>;
+    noEnumMerging: DiagnosticFactory<[]>;
+    noNamespaceMerging: DiagnosticFactory<[]>;
+    noFunctionExpressionName: DiagnosticFactory<[]>;
+    noPrecedingSpreadElement: DiagnosticFactory<[]>;
+    noLuaTupleDestructureAssignmentExpression: DiagnosticFactory<[]>;
+    noExportAssignmentLet: DiagnosticFactory<[]>;
+    noGlobalThis: DiagnosticFactory<[]>;
+    noArguments: DiagnosticFactory<[]>;
+    noPrototype: DiagnosticFactory<[]>;
+    noRobloxSymbolInstanceof: DiagnosticFactory<[]>;
+    noNestedSpreadsInAssignmentPatterns: DiagnosticFactory<[]>;
+    noRestSpreadingOfRobloxTypes: DiagnosticFactory<[]>;
+    noNonNumberStringRelationOperator: DiagnosticFactory<[]>;
+    noInstanceMethodCollisions: DiagnosticFactory<[]>;
+    noStaticMethodCollisions: DiagnosticFactory<[]>;
+    noUnaryPlus: DiagnosticFactory<[]>;
+    noNonNumberUnaryMinus: DiagnosticFactory<[]>;
+    noAwaitForOf: DiagnosticFactory<[]>;
+    noAsyncGeneratorFunctions: DiagnosticFactory<[]>;
+    noNonStringModuleSpecifier: DiagnosticFactory<[]>;
+    noIterableIteration: DiagnosticFactory<[]>;
+    noMixedTypeCall: DiagnosticFactory<[]>;
+    noIndexWithoutCall: DiagnosticFactory<[]>;
+    noCommentDirectives: DiagnosticFactory<[]>;
+    noOptionalMacroCall: DiagnosticFactory<[]>;
+    noConstructorMacroWithoutNew: DiagnosticFactory<[]>;
+    noMacroExtends: DiagnosticFactory<[]>;
+    noMacroUnion: DiagnosticFactory<[]>;
+    noMacroObjectSpread: DiagnosticFactory<[]>;
+    noVarArgsMacroSpread: DiagnosticFactory<[]>;
+    noRangeMacroOutsideForOf: DiagnosticFactory<[]>;
+    noTupleMacroOutsideReturn: DiagnosticFactory<[]>;
+    noModuleSpecifierFile: DiagnosticFactory<[]>;
+    noInvalidModule: DiagnosticFactory<[]>;
+    noUnscopedModule: DiagnosticFactory<[]>;
+    noNonModuleImport: DiagnosticFactory<[]>;
+    noIsolatedImport: DiagnosticFactory<[]>;
+    noServerImport: DiagnosticFactory<[]>;
+    noPrecedingJsxSpreadElement: DiagnosticFactory<[]>;
+    expectedMethodGotFunction: DiagnosticFactory<[]>;
+    expectedFunctionGotMethod: DiagnosticFactory<[]>;
+    noRojoData: DiagnosticFactory<[path: string, isPackage: boolean]>;
+    noPackageImportWithoutScope: DiagnosticFactory<[path: string, rbxPath: RbxPath]>;
+    incorrectFileName: (originalFileName: string, suggestedFileName: string, fullPath: string) => ts.Diagnostic;
+    rojoPathInSrc: (partitionPath: string, suggestedPath: string) => ts.Diagnostic;
+};
+export declare const warnings: {
+    truthyChange: (checksStr: string) => DiagnosticFactory<[]>;
+    stringOffsetChange: (text: string) => DiagnosticFactory<[]>;
+    transformerNotFound: (name: string, err: unknown) => ts.Diagnostic;
+    runtimeLibUsedInReplicatedFirst: DiagnosticFactory<[]>;
+};

package/out/Shared/diagnostics.js

@@ -0,0 +1,140 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnings = exports.errors = void 0;
+exports.getDiagnosticId = getDiagnosticId;
+const kleur_1 = __importDefault(require("kleur"));
+const createDiagnosticWithLocation_1 = require("./util/createDiagnosticWithLocation");
+const createGithubLink_1 = require("./util/createGithubLink");
+const createTextDiagnostic_1 = require("./util/createTextDiagnostic");
+const typescript_1 = __importDefault(require("typescript"));
+function suggestion(text) {
+    return "Suggestion: " + kleur_1.default.yellow(text);
+}
+let id = 0;
+function diagnostic(category, ...messages) {
+    return diagnosticWithContext(category, undefined, ...messages);
+}
+function diagnosticWithContext(category, contextFormatter, ...messages) {
+    const result = (node, ...context) => {
+        if (category === typescript_1.default.DiagnosticCategory.Error &&
+            process.env.ROBLOX_TS_EXPECTED_DIAGNOSTIC_ID !== String(result.id)) {
+            debugger;
+        }
+        if (contextFormatter) {
+            messages.push(...contextFormatter(...context));
+        }
+        return (0, createDiagnosticWithLocation_1.createDiagnosticWithLocation)(result.id, messages.filter(v => v !== false).join("\n"), category, node);
+    };
+    result.id = id++;
+    return result;
+}
+function diagnosticText(category, ...messages) {
+    return (0, createTextDiagnostic_1.createTextDiagnostic)(messages.filter(v => v !== false).join("\n"), category);
+}
+function error(...messages) {
+    return diagnostic(typescript_1.default.DiagnosticCategory.Error, ...messages);
+}
+function errorWithContext(contextFormatter, ...messages) {
+    return diagnosticWithContext(typescript_1.default.DiagnosticCategory.Error, contextFormatter, ...messages);
+}
+function errorText(...messages) {
+    return diagnosticText(typescript_1.default.DiagnosticCategory.Error, ...messages);
+}
+function warning(...messages) {
+    return diagnostic(typescript_1.default.DiagnosticCategory.Warning, ...messages);
+}
+function warningText(...messages) {
+    return diagnosticText(typescript_1.default.DiagnosticCategory.Warning, ...messages);
+}
+function getDiagnosticId(diagnostic) {
+    return diagnostic.id;
+}
+exports.errors = {
+    noInvalidIdentifier: error("Invalid Luau identifier!", "Luau identifiers must start with a letter and only contain letters, numbers, and underscores.", "Reserved Luau keywords cannot be used as identifiers."),
+    noReservedIdentifier: error("Cannot use identifier reserved for compiler internal usage."),
+    noReservedClassFields: error("Cannot use class field reserved for compiler internal usage."),
+    noClassMetamethods: error("Metamethods cannot be used in class definitions!"),
+    noForInStatement: error("for-in loop statements are not supported!"),
+    noLabeledStatement: error("labels are not supported!"),
+    noDebuggerStatement: error("`debugger` is not supported!"),
+    noNullLiteral: error("`null` is not supported!", suggestion("Use `undefined` instead.")),
+    noPrivateIdentifier: error("Private identifiers are not supported!"),
+    noTypeOfExpression: error("`typeof` operator is not supported!", suggestion("Use `typeIs(value, type)` or `typeOf(value)` instead.")),
+    noRegex: error("Regular expressions are not supported!"),
+    noBigInt: error("BigInt literals are not supported!"),
+    noAny: error("Using values of type `any` is not supported!", suggestion("Use `unknown` instead.")),
+    noVar: error("`var` keyword is not supported!", suggestion("Use `let` or `const` instead.")),
+    noGetterSetter: error("Getters and Setters are not supported!", (0, createGithubLink_1.issue)(457)),
+    noAutoAccessorModifiers: error("Getters and Setters are not supported!", "The `accessor` keyword requires generating get/set accessors", (0, createGithubLink_1.issue)(457)),
+    noEqualsEquals: error("operator `==` is not supported!", suggestion("Use `===` instead.")),
+    noExclamationEquals: error("operator `!=` is not supported!", suggestion("Use `!==` instead.")),
+    noEnumMerging: error("Enum merging is not supported!"),
+    noNamespaceMerging: error("Namespace merging is not supported!"),
+    noFunctionExpressionName: error("Function expression names are not supported!"),
+    noPrecedingSpreadElement: error("Spread element must come last in a list of arguments!"),
+    noLuaTupleDestructureAssignmentExpression: error("Cannot destructure LuaTuple<T> expression outside of an ExpressionStatement!"),
+    noExportAssignmentLet: error("Cannot use `export =` on a `let` variable!", suggestion("Use `const` instead.")),
+    noGlobalThis: error("`globalThis` is not supported!"),
+    noArguments: error("`arguments` is not supported!"),
+    noPrototype: error("`prototype` is not supported!"),
+    noRobloxSymbolInstanceof: error("The `instanceof` operator can only be used on roblox-ts classes!", suggestion('Use `typeIs(myThing, "TypeToCheck") instead')),
+    noNestedSpreadsInAssignmentPatterns: error("Nesting spreads in assignment patterns is not supported!"),
+    noRestSpreadingOfRobloxTypes: error("Operator `...` is not allowed on Roblox types!"),
+    noNonNumberStringRelationOperator: error("Relation operators can only be used on number or string types!"),
+    noInstanceMethodCollisions: error("Static methods cannot use the same name as instance methods!"),
+    noStaticMethodCollisions: error("Instance methods cannot use the same name as static methods!"),
+    noUnaryPlus: error("Unary `+` is not supported!", suggestion("Use `tonumber(x)` instead.")),
+    noNonNumberUnaryMinus: error("Unary `-` is only supported for number types!"),
+    noAwaitForOf: error("`await` is not supported in for-of loops!"),
+    noAsyncGeneratorFunctions: error("Async generator functions are not supported!"),
+    noNonStringModuleSpecifier: error("Module specifiers must be a string literal."),
+    noIterableIteration: error("Iterating on Iterable<T> is not supported! You must use a more specific type."),
+    noMixedTypeCall: error("Attempted to call a function with mixed types! All definitions must either be a method or a callback."),
+    noIndexWithoutCall: error("Cannot index a method without calling it!", suggestion("Use the form `() => a.b()` instead of `a.b`.")),
+    noCommentDirectives: error("Usage of `@ts-ignore`, `@ts-expect-error`, and `@ts-nocheck` are not supported!", "roblox-ts needs type and symbol info to compile correctly.", suggestion("Consider using type assertions or `declare` statements.")),
+    noOptionalMacroCall: error("Macro methods can not be optionally called!", suggestion("Macros always exist. Use a normal call.")),
+    noConstructorMacroWithoutNew: error("Cannot index a constructor macro without using the `new` operator!"),
+    noMacroExtends: error("Cannot extend from a macro class!", suggestion("Store an instance of the macro class in a property.")),
+    noMacroUnion: error("Macro cannot be applied to a union type!"),
+    noMacroObjectSpread: error("Macro classes cannot be used in an object spread!", suggestion("Did you mean to use an array spread? `[ ...exp ]`")),
+    noVarArgsMacroSpread: error("Macros which use variadic arguments do not support spread expressions!", (0, createGithubLink_1.issue)(1149)),
+    noRangeMacroOutsideForOf: error("$range() macro is only valid as an expression of a for-of loop!"),
+    noTupleMacroOutsideReturn: error("$tuple() macro is only valid as an expression of a return statement!"),
+    noModuleSpecifierFile: error("Could not find file for import. Did you forget to `npm install`?"),
+    noInvalidModule: error("You can only use npm scopes that are listed in your typeRoots."),
+    noUnscopedModule: error("You cannot use modules directly under node_modules."),
+    noNonModuleImport: error("Cannot import a non-ModuleScript!"),
+    noIsolatedImport: error("Attempted to import a file inside of an isolated container from outside!"),
+    noServerImport: error("Cannot import a server file from a shared or client location!", suggestion("Move the file you want to import to a shared location.")),
+    noPrecedingJsxSpreadElement: error("JSX spread expression must come last in children!"),
+    expectedMethodGotFunction: error("Attempted to assign non-method where method was expected."),
+    expectedFunctionGotMethod: error("Attempted to assign method where non-method was expected."),
+    noRojoData: errorWithContext((path, isPackage) => [
+        `Could not find Rojo data. There is no $path in your Rojo config that covers ${path}`,
+        isPackage && suggestion(`Did you forget to add a custom npm scope to your default.project.json?`),
+    ]),
+    noPackageImportWithoutScope: errorWithContext((path, rbxPath) => [
+        `Imported package Roblox path is missing an npm scope!`,
+        `Package path: ${path}`,
+        `Roblox path: ${rbxPath.join(".")}`,
+        suggestion(`You might need to update your "node_modules" in default.project.json to match:
+"node_modules": {
+	"$className": "Folder",
+	"@rbxts": {
+		"$path": "node_modules/@rbxts"
+	}
+}`),
+    ]),
+    incorrectFileName: (originalFileName, suggestedFileName, fullPath) => errorText(`Incorrect file name: \`${originalFileName}\`!`, `Full path: ${fullPath}`, suggestion(`Change \`${originalFileName}\` to \`${suggestedFileName}\`.`)),
+    rojoPathInSrc: (partitionPath, suggestedPath) => errorText(`Invalid Rojo configuration. $path fields should be relative to out directory.`, suggestion(`Change the value of $path from "${partitionPath}" to "${suggestedPath}".`)),
+};
+exports.warnings = {
+    truthyChange: (checksStr) => warning(`Value will be checked against ${checksStr}`),
+    stringOffsetChange: (text) => warning(`String macros no longer offset inputs: ${text}`),
+    transformerNotFound: (name, err) => warningText(`Transformer \`${name}\` was not found!`, "More info: " + err, suggestion("Did you forget to install the package?")),
+    runtimeLibUsedInReplicatedFirst: warning("This statement would generate a call to the runtime library. The runtime library should not be used from ReplicatedFirst."),
+};
+//# sourceMappingURL=diagnostics.js.map

package/out/Shared/errors/DiagnosticError.d.ts

@@ -0,0 +1,7 @@
+import { LoggableError } from "./LoggableError";
+import ts from "typescript";
+export declare class DiagnosticError extends LoggableError {
+    readonly diagnostics: ReadonlyArray<ts.Diagnostic>;
+    constructor(diagnostics: ReadonlyArray<ts.Diagnostic>);
+    toString(): string;
+}

package/out/Shared/errors/DiagnosticError.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticError = void 0;
+const LoggableError_1 = require("./LoggableError");
+const formatDiagnostics_1 = require("../util/formatDiagnostics");
+class DiagnosticError extends LoggableError_1.LoggableError {
+    constructor(diagnostics) {
+        super();
+        this.diagnostics = diagnostics;
+    }
+    toString() {
+        return (0, formatDiagnostics_1.formatDiagnostics)(this.diagnostics);
+    }
+}
+exports.DiagnosticError = DiagnosticError;
+//# sourceMappingURL=DiagnosticError.js.map

package/out/Shared/errors/LoggableError.d.ts

@@ -0,0 +1,5 @@
+export declare abstract class LoggableError {
+    constructor();
+    abstract toString(): string;
+    log(): void;
+}

package/out/Shared/errors/LoggableError.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggableError = void 0;
+const LogService_1 = require("../classes/LogService");
+class LoggableError {
+    constructor() {
+        debugger;
+    }
+    log() {
+        LogService_1.LogService.writeLine(this.toString());
+    }
+}
+exports.LoggableError = LoggableError;
+//# sourceMappingURL=LoggableError.js.map

package/out/Shared/errors/ProjectError.d.ts

@@ -0,0 +1,4 @@
+import { DiagnosticError } from "./DiagnosticError";
+export declare class ProjectError extends DiagnosticError {
+    constructor(message: string);
+}

package/out/Shared/errors/ProjectError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectError = void 0;
+const DiagnosticError_1 = require("./DiagnosticError");
+const createTextDiagnostic_1 = require("../util/createTextDiagnostic");
+class ProjectError extends DiagnosticError_1.DiagnosticError {
+    constructor(message) {
+        super([(0, createTextDiagnostic_1.createTextDiagnostic)(message)]);
+    }
+}
+exports.ProjectError = ProjectError;
+//# sourceMappingURL=ProjectError.js.map

package/out/Shared/index.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=index.js.map

package/out/Shared/types.d.ts

@@ -0,0 +1,50 @@
+import { PathTranslator } from "@roblox-ts/path-translator";
+import { ProjectType } from "./constants";
+import ts from "typescript";
+export interface ProjectOptions {
+    includePath: string;
+    rojo: string | undefined;
+    type: ProjectType | undefined;
+    logTruthyChanges: boolean;
+    noInclude: boolean;
+    usePolling: boolean;
+    verbose: boolean;
+    watch: boolean;
+    writeOnlyChanged: boolean;
+    writeTransformedFiles: boolean;
+    optimizedLoops: boolean;
+    allowCommentDirectives: boolean;
+    luau: boolean;
+}
+export interface ProjectData {
+    readonly isPackage: boolean;
+    readonly nodeModulesPath: string;
+    readonly projectOptions: ProjectOptions;
+    readonly projectPath: string;
+    readonly rojoConfigPath: string | undefined;
+    readonly tsConfigPath: string;
+    transformerWatcher?: TransformerWatcher;
+    readonly referencedProjects: Array<ReferencedProjectInfo>;
+}
+export interface ReferencedProjectInfo {
+    readonly tsConfigPath: string;
+    readonly rootDir: string;
+    readonly outDir: string;
+}
+export type GetProjectPathTranslator = (tsConfigPath: string) => PathTranslator;
+export interface TransformerWatcher {
+    service: ts.LanguageService;
+    updateFile: (fileName: string, text: string) => void;
+}
+export interface TransformerPluginConfig {
+    transform?: string;
+    import?: string;
+    type?: "program" | "config" | "checker" | "raw" | "compilerOptions";
+    after?: boolean;
+    afterDeclarations?: boolean;
+    [options: string]: unknown;
+}
+export interface SourceFileWithTextRange {
+    sourceFile: ts.SourceFile;
+    range: ts.ReadonlyTextRange;
+}

package/out/Shared/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/out/Shared/util/assert.d.ts

@@ -0,0 +1 @@
+export declare function assert(value: unknown, message?: string): asserts value;

package/out/Shared/util/assert.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = assert;
+function assert(value, message) {
+    if (!value) {
+        debugger;
+        throw new Error(`Assertion Failed! ${message !== null && message !== void 0 ? message : ""}` +
+            "\nThis is a compiler bug! Please submit a bug report here:" +
+            "\nhttps://github.com/roblox-ts/roblox-ts/issues");
+    }
+}
+//# sourceMappingURL=assert.js.map

package/out/Shared/util/benchmark.d.ts

@@ -0,0 +1,3 @@
+export declare function benchmarkSync(name: string, callback: () => void): void;
+export declare function benchmarkIfVerbose(name: string, callback: () => void): void;
+export declare function benchmark<T>(name: string, callback: () => Promise<T>): Promise<void>;

package/out/Shared/util/benchmark.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.benchmarkSync = benchmarkSync;
+exports.benchmarkIfVerbose = benchmarkIfVerbose;
+exports.benchmark = benchmark;
+const LogService_1 = require("../classes/LogService");
+function benchmarkStart(name) {
+    LogService_1.LogService.write(`${name}`);
+    return Date.now();
+}
+function benchmarkEnd(startTime) {
+    LogService_1.LogService.write(` ( ${Date.now() - startTime} ms )\n`);
+}
+function benchmarkSync(name, callback) {
+    const startTime = benchmarkStart(name);
+    callback();
+    benchmarkEnd(startTime);
+}
+function benchmarkIfVerbose(name, callback) {
+    if (LogService_1.LogService.verbose) {
+        benchmarkSync(name, callback);
+    }
+    else {
+        callback();
+    }
+}
+async function benchmark(name, callback) {
+    const startTime = benchmarkStart(name);
+    await callback();
+    benchmarkEnd(startTime);
+}
+//# sourceMappingURL=benchmark.js.map

package/out/Shared/util/createDiagnosticWithLocation.d.ts

@@ -0,0 +1,3 @@
+import { SourceFileWithTextRange } from "../types";
+import ts from "typescript";
+export declare function createDiagnosticWithLocation(id: number, messageText: string, category: ts.DiagnosticCategory, node: ts.Node | SourceFileWithTextRange): ts.DiagnosticWithLocation;

package/out/Shared/util/createDiagnosticWithLocation.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDiagnosticWithLocation = createDiagnosticWithLocation;
+function createDiagnosticWithLocation(id, messageText, category, node) {
+    const code = " roblox-ts";
+    if ("kind" in node) {
+        return {
+            category,
+            code,
+            messageText,
+            id,
+            file: node.getSourceFile(),
+            start: node.getStart(),
+            length: node.getWidth(),
+        };
+    }
+    else {
+        return {
+            category,
+            code,
+            messageText,
+            id,
+            file: node.sourceFile,
+            start: node.range.pos,
+            length: node.range.end,
+        };
+    }
+}
+//# sourceMappingURL=createDiagnosticWithLocation.js.map

package/out/Shared/util/createGithubLink.d.ts

@@ -0,0 +1 @@
+export declare function issue(id: number): string;

package/out/Shared/util/createGithubLink.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.issue = issue;
+const kleur_1 = __importDefault(require("kleur"));
+const REPO_URL = "https://github.com/roblox-ts/roblox-ts";
+function issue(id) {
+    return "More information: " + kleur_1.default.grey(`${REPO_URL}/issues/${id}`);
+}
+//# sourceMappingURL=createGithubLink.js.map

package/out/Shared/util/createTextDiagnostic.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function createTextDiagnostic(messageText: string, category?: ts.DiagnosticCategory): ts.Diagnostic;

package/out/Shared/util/createTextDiagnostic.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTextDiagnostic = createTextDiagnostic;
+const typescript_1 = __importDefault(require("typescript"));
+function createTextDiagnostic(messageText, category = typescript_1.default.DiagnosticCategory.Error) {
+    return {
+        category,
+        code: " roblox-ts",
+        file: undefined,
+        messageText,
+        start: undefined,
+        length: undefined,
+    };
+}
+//# sourceMappingURL=createTextDiagnostic.js.map

package/out/Shared/util/findAncestorDir.d.ts

@@ -0,0 +1 @@
+export declare function findAncestorDir(dirs: Array<string>): string;

package/out/Shared/util/findAncestorDir.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAncestorDir = findAncestorDir;
+const path_1 = __importDefault(require("path"));
+function findAncestorDir(dirs) {
+    dirs = dirs.map(path_1.default.normalize).map(v => (v.endsWith(path_1.default.sep) ? v : v + path_1.default.sep));
+    let currentDir = dirs[0];
+    while (!dirs.every(v => v.startsWith(currentDir))) {
+        currentDir = path_1.default.join(currentDir, "..");
+    }
+    return currentDir;
+}
+//# sourceMappingURL=findAncestorDir.js.map

package/out/Shared/util/findLastIndex.d.ts

@@ -0,0 +1 @@
+export declare function findLastIndex<T>(array: ReadonlyArray<T>, callback: (value: T) => boolean): number;

package/out/Shared/util/findLastIndex.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLastIndex = findLastIndex;
+function findLastIndex(array, callback) {
+    for (let i = array.length - 1; i >= 0; i--) {
+        if (callback(array[i])) {
+            return i;
+        }
+    }
+    return -1;
+}
+//# sourceMappingURL=findLastIndex.js.map

package/out/Shared/util/formatDiagnostics.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function formatDiagnostics(diagnostics: ReadonlyArray<ts.Diagnostic>): string;

package/out/Shared/util/formatDiagnostics.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.formatDiagnostics = formatDiagnostics;
+const os_1 = require("os");
+const typescript_1 = __importDefault(require("typescript"));
+function createFormatDiagnosticsHost() {
+    return {
+        getCurrentDirectory: () => process.cwd(),
+        getCanonicalFileName: fileName => fileName,
+        getNewLine: () => os_1.EOL,
+    };
+}
+function formatDiagnostics(diagnostics) {
+    return typescript_1.default.formatDiagnosticsWithColorAndContext(diagnostics, createFormatDiagnosticsHost());
+}
+//# sourceMappingURL=formatDiagnostics.js.map

package/out/Shared/util/getCanonicalFileName.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare const getCanonicalFileName: ts.GetCanonicalFileName;

package/out/Shared/util/getCanonicalFileName.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCanonicalFileName = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+exports.getCanonicalFileName = typescript_1.default.createGetCanonicalFileName((_b = (_a = typescript_1.default.sys) === null || _a === void 0 ? void 0 : _a.useCaseSensitiveFileNames) !== null && _b !== void 0 ? _b : true);
+//# sourceMappingURL=getCanonicalFileName.js.map

package/out/Shared/util/getOrSetDefault.d.ts

@@ -0,0 +1 @@
+export declare function getOrSetDefault<K, V>(map: Map<K, V>, key: K, getDefaultValue: () => V): V;

package/out/Shared/util/getOrSetDefault.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOrSetDefault = getOrSetDefault;
+function getOrSetDefault(map, key, getDefaultValue) {
+    let value = map.get(key);
+    if (value === undefined) {
+        value = getDefaultValue();
+        map.set(key, value);
+    }
+    return value;
+}
+//# sourceMappingURL=getOrSetDefault.js.map

package/out/Shared/util/getRootDirs.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function getRootDirs(compilerOptions: ts.CompilerOptions): string[];

package/out/Shared/util/getRootDirs.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRootDirs = getRootDirs;
+const assert_1 = require("./assert");
+function getRootDirs(compilerOptions) {
+    const rootDirs = compilerOptions.rootDir ? [compilerOptions.rootDir] : compilerOptions.rootDirs;
+    (0, assert_1.assert)(rootDirs);
+    return rootDirs;
+}
+//# sourceMappingURL=getRootDirs.js.map

package/out/Shared/util/hasErrors.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function hasErrors(diagnostics: ReadonlyArray<ts.Diagnostic>): boolean;

package/out/Shared/util/hasErrors.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.hasErrors = hasErrors;
+const typescript_1 = __importDefault(require("typescript"));
+function hasErrors(diagnostics) {
+    return diagnostics.some(d => d.category === typescript_1.default.DiagnosticCategory.Error);
+}
+//# sourceMappingURL=hasErrors.js.map

package/out/Shared/util/isPathDescendantOf.d.ts

@@ -0,0 +1 @@
+export declare function isPathDescendantOf(filePath: string, dirPath: string): boolean;

package/out/Shared/util/isPathDescendantOf.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.isPathDescendantOf = isPathDescendantOf;
+const path_1 = __importDefault(require("path"));
+function isPathDescendantOf(filePath, dirPath) {
+    return dirPath === filePath || !path_1.default.relative(dirPath, filePath).startsWith("..");
+}
+//# sourceMappingURL=isPathDescendantOf.js.map

package/out/Shared/util/realPathExistsSync.d.ts

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