luaut-parser 1.1.0 → 2.0.0

package/dist/index.cjs

@@ -21,6 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   BinaryOperators: () => BinaryOperators,
+  CONFIG_FILE_NAMES: () => CONFIG_FILE_NAMES,
   Keywords: () => Keywords,
   LexError: () => LexError,
   Operators: () => Operators,
@@ -35,10 +36,10 @@ __export(index_exports, {
   bufferType: () => bufferType,
   containsTypeParam: () => containsTypeParam,
   default: () => index_default,
-  defaultLibs: () => defaultLibs,
   difference: () => difference,
   equalTypes: () => equalTypes,
   falsyType: () => falsyType,
+  findConfig: () => findConfig,
   fn: () => fn,
   formatType: () => formatType,
   getBinding: () => getBinding,
@@ -49,11 +50,10 @@ __export(index_exports, {
   isPossiblyTruthy: () => isPossiblyTruthy,
   isUnassignedGlobal: () => isUnassignedGlobal,
   literal: () => literal,
-  luauDefs: () => luauDefs,
-  luauDefsPath: () => luauDefsPath,
-  luauLib: () => luauLib,
+  loadConfig: () => loadConfig,
   luautparser: () => luautparser,
   matchInfer: () => matchInfer,
+  moduleCandidates: () => moduleCandidates,
   moduleExports: () => moduleExports,
   narrowExclude: () => narrowExclude,
   narrowFalsy: () => narrowFalsy,
@@ -61,6 +61,7 @@ __export(index_exports, {
   narrowTruthy: () => narrowTruthy,
   neverType: () => neverType,
   nilType: () => nilType,
+  nodeHost: () => nodeHost,
   numberType: () => numberType,
   objectType: () => objectType,
   optional: () => optional,
@@ -70,11 +71,12 @@ __export(index_exports, {
   parseTokens: () => parseTokens,
   parseWithRecovery: () => parseWithRecovery,
   primitive: () => primitive,
-  robloxDefs: () => robloxDefs,
-  robloxDefsPath: () => robloxDefsPath,
-  robloxLib: () => robloxLib,
+  resolveModulePath: () => resolveModulePath,
+  resolveTypeLibraries: () => resolveTypeLibraries,
   setAliasExpander: () => setAliasExpander,
+  sourceMapTypes: () => sourceMapTypes,
   stringType: () => stringType,
+  stripJsonComments: () => stripJsonComments,
   substitute: () => substitute,
   templateMatches: () => templateMatches,
   threadType: () => threadType,
@@ -88,10 +90,6 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
-// node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
-var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
-
 // src/lexer/lexer.ts
 var Keywords = [
   "and",
@@ -3270,7 +3268,11 @@ function isAssignableInner(a, b) {
   if (a.kind === "union") return a.types.every((t) => isAssignable(t, b));
   if (b.kind === "union") return b.types.some((t) => isAssignable(a, t));
   if (b.kind === "intersection") return b.types.every((t) => isAssignable(a, t));
-  if (a.kind === "intersection") return a.types.some((t) => isAssignable(t, b));
+  if (a.kind === "intersection") {
+    if (a.types.some((t) => isAssignable(t, b))) return true;
+    const merged = mergeObjectMembers(a.types);
+    return merged !== void 0 && isAssignable(merged, b);
+  }
   if (a.kind === "literal") {
     if (b.kind === "literal") return a.value === b.value;
     if (b.kind === "primitive") return b.name === a.base;
@@ -3625,6 +3627,39 @@ var IDENT_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function formatKey(k) {
   return IDENT_KEY.test(k) ? k : JSON.stringify(k);
 }
+function mergeObjectMembers(types) {
+  const objects = [];
+  const seen = /* @__PURE__ */ new Set();
+  const collect = (t) => {
+    if (seen.has(t)) return true;
+    seen.add(t);
+    if (t.kind === "genericRef") {
+      const expanded = expandAlias?.(t);
+      return expanded !== void 0 && expanded !== t && collect(expanded);
+    }
+    if (t.kind === "intersection") return t.types.every(collect);
+    if (t.kind === "object") {
+      objects.push(t);
+      return true;
+    }
+    return false;
+  };
+  if (!types.every(collect) || objects.length < 2) return void 0;
+  const properties = /* @__PURE__ */ new Map();
+  let indexer;
+  for (const object of objects) {
+    indexer ??= object.indexer;
+    for (const [name, property] of object.properties) {
+      const existing = properties.get(name);
+      properties.set(name, existing ? {
+        type: intersection([existing.type, property.type]),
+        optional: existing.optional && property.optional,
+        readonly: existing.readonly || property.readonly
+      } : property);
+    }
+  }
+  return objectType([...properties], indexer);
+}
 
 // src/ast/analyzeTypes.ts
 function analyzeTypes(program, scopes, options = {}) {
@@ -3832,6 +3867,7 @@ var TypeAnalyzer = class {
   bindingType = /* @__PURE__ */ new Map();
   narrowedTypeOf = /* @__PURE__ */ new Map();
   typeOfTypeNode = /* @__PURE__ */ new Map();
+  expectedTypeOf = /* @__PURE__ */ new Map();
   /** Public: each alias resolved once (generic aliases keep their params as
    *  `typeParam` nodes in the body). */
   aliases = /* @__PURE__ */ new Map();
@@ -3897,6 +3933,7 @@ var TypeAnalyzer = class {
       bindingType: this.bindingType,
       narrowedTypeOf: this.narrowedTypeOf,
       typeOfTypeNode: this.typeOfTypeNode,
+      expectedTypeOf: this.expectedTypeOf,
       aliases: this.resolveDeferredAliases(),
       diagnostics: this.diagnostics
     };
@@ -4878,16 +4915,76 @@ var TypeAnalyzer = class {
     return void 0;
   }
   /** Can this signature be called with these argument types? The signature's
-   *  own generic parameters act as wildcards — they are what the call would
-   *  infer, so they must not make the match fail. */
+   *  own type parameters stand for what the call would infer, so each is
+   *  checked only against its constraint — `<K extends keyof Services>`
+   *  accepts `"Players"` but not `""`. */
   overloadAccepts(f, argTypes) {
     if (!f.varargs && argTypes.length > f.params.length) return false;
-    const wildcards = new Map((f.typeParams ?? []).map((n) => [n, anyType]));
+    const params = this.boundParams(f);
     return f.params.every((p, i) => {
       if (argTypes[i] === void 0) return p.optional === true;
-      return isAssignable(argTypes[i], substitute(p.type, wildcards));
+      return isAssignable(argTypes[i], params[i]);
     });
   }
+  /** A signature's parameter types as a call site sees them before inference:
+   *  each type parameter replaced by its constraint, or by `any` when it has
+   *  none — or when the constraint mentions another type parameter, which a
+   *  lone argument cannot be checked against without false errors. */
+  boundParams(f) {
+    if (!f.typeParams?.length) return f.params.map((p) => p.type);
+    const bounds = new Map(f.typeParams.map((name) => [name, anyType]));
+    const seen = /* @__PURE__ */ new WeakSet();
+    const walk = (value) => {
+      if (!value || typeof value !== "object" || seen.has(value)) return;
+      seen.add(value);
+      if (value instanceof Map) {
+        value.forEach(walk);
+        return;
+      }
+      const t = value;
+      if (t.kind === "typeParam" && typeof t.name === "string" && bounds.has(t.name) && t.constraint && !containsTypeParam(t.constraint)) {
+        bounds.set(t.name, this.reduceType(t.constraint));
+      }
+      for (const child of Object.values(value)) walk(child);
+    };
+    for (const p of f.params) walk(p.type);
+    return f.params.map((p) => substitute(p.type, bounds));
+  }
+  /** Record what each written argument is expected to be — see
+   *  `TypeAnalysis.expectedTypeOf`. */
+  recordExpected(written, fns, selfOf) {
+    written.forEach((arg, j) => {
+      const candidates = [];
+      for (const f of fns) {
+        const i = j + selfOf(f);
+        const param = i < f.params.length ? this.boundParams(f)[i] : f.varargs;
+        if (param) candidates.push(param);
+      }
+      if (candidates.length) this.expectedTypeOf.set(arg, union(candidates));
+    });
+  }
+  /** No signature accepts the call, and the argument count is not the
+   *  problem: say which argument is wrong, the way TypeScript does. */
+  reportArguments(call, written, fns, argsFor, selfOf) {
+    if (!this.emitDiagnostics) return;
+    if (fns.length > 1) {
+      this.diagnostics.push({ node: call, message: "No overload matches this call" });
+      return;
+    }
+    const f = fns[0];
+    const args = argsFor(f);
+    const params = this.boundParams(f);
+    const self = selfOf(f);
+    for (let i = 0; i < f.params.length; i++) {
+      const arg = args[i];
+      if (arg === void 0 || isAssignable(arg, params[i])) continue;
+      this.diagnostics.push({
+        node: written[i - self] ?? call,
+        message: `Argument of type '${formatType(arg)}' is not assignable to parameter of type '${briefType(params[i])}'`
+      });
+      return;
+    }
+  }
   /** A required parameter may not follow an optional one — otherwise the
    *  optional one could never actually be omitted. Same rule as TypeScript,
    *  and it applies to a default (`a = 1`) as much as to a `?`. */
@@ -4917,22 +5014,25 @@ var TypeAnalyzer = class {
     return { min, max: f.varargs ? void 0 : f.params.length };
   }
   /** Report a call that passes too few or too many arguments. Only fires
-   *  when *no* overload accepts the call, so an overload set still reports
-   *  once, against its first signature. */
+   *  when *no* overload accepts the count, so an overload set still reports
+   *  once, against its first signature. Returns whether the count fits, so
+   *  an argument's type is only complained about when its count is right. */
   checkArity(node, fns, argCount, selfArgs) {
-    if (!this.emitDiagnostics || !fns.length) return;
+    if (!fns.length) return true;
     const fits = fns.some((f) => {
       const { min: min2, max: max2 } = this.arityOf(f);
       const n = argCount + selfArgs;
       return n >= min2 && (max2 === void 0 || n <= max2);
     });
-    if (fits) return;
+    if (fits) return true;
+    if (!this.emitDiagnostics) return false;
     const { min, max } = this.arityOf(fns[0]);
     const need = max === void 0 ? `at least ${min - selfArgs}` : min === max ? `${min - selfArgs}` : `${min - selfArgs}-${max - selfArgs}`;
     this.diagnostics.push({
       node,
       message: `Expected ${need} argument${need === "1" ? "" : "s"}, got ${argCount}`
     });
+    return false;
   }
   signatureToFnType(sig) {
     const names = sig.generics.map((g) => g.name);
@@ -5370,11 +5470,13 @@ var TypeAnalyzer = class {
         const argTypes = expr.arguments.map((a) => this.infer(a, env));
         const fns = this.overloadsOf(callee);
         if (fns.length) {
-          this.checkArity(expr, fns, argTypes.length, 0);
+          this.recordExpected(expr.arguments, fns, () => 0);
+          const arityFits = this.checkArity(expr, fns, argTypes.length, 0);
           const picked = this.pickOverload(fns, argTypes);
           if (picked) {
             return this.callReturn(picked, this.constArgs(picked, expr.arguments, argTypes, env));
           }
+          if (arityFits) this.reportArguments(expr, expr.arguments, fns, () => argTypes, () => 0);
           return union(fns.map((f) => this.callReturn(f, argTypes)));
         }
         return callee.kind === "any" ? anyType : unknownType;
@@ -5385,13 +5487,16 @@ var TypeAnalyzer = class {
         const fns = this.overloadsOf(this.propertyType(objType, expr.method.name));
         if (fns.length) {
           const withSelf = (f) => this.takesSelf(f) ? [objType, ...argTypes] : argTypes;
-          this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
+          const selfOf = (f) => this.takesSelf(f) ? 1 : 0;
+          this.recordExpected(expr.arguments, fns, selfOf);
+          const arityFits = this.checkArity(expr, fns, argTypes.length, this.takesSelf(fns[0]) ? 1 : 0);
           const picked = this.pickOverload(fns, argTypes, withSelf);
           if (picked) {
             const self = this.takesSelf(picked) ? 1 : 0;
             const written = this.constArgs(picked, expr.arguments, argTypes, env, self);
             return this.callReturn(picked, this.takesSelf(picked) ? [objType, ...written] : written);
           }
+          if (arityFits) this.reportArguments(expr, expr.arguments, fns, withSelf, selfOf);
           return union(fns.map((f) => this.callReturn(f, withSelf(f))));
         }
         return objType.kind === "any" ? anyType : unknownType;
@@ -5839,23 +5944,376 @@ function containsTypeQuery(node) {
   if (node.type === "TypeofTypeNode") return true;
   return Object.values(node).some(containsTypeQuery);
 }
+function briefType(t) {
+  if (t.kind === "union" && t.types.length > 8) {
+    const shown = t.types.slice(0, 6).map(formatType).join(" | ");
+    return `${shown} | ... ${t.types.length - 6} more`;
+  }
+  return formatType(t);
+}
 
-// src/lib/luau.ts
+// src/project/host.ts
 var import_node_fs = require("fs");
-var import_node_url = require("url");
-var luauDefsPath = (0, import_node_url.fileURLToPath)(new URL("./luau.d.luaut", importMetaUrl));
-var luauDefs = (0, import_node_fs.readFileSync)(luauDefsPath, "utf8");
-var luauLib = parse(luauDefs);
+var nodeHost = {
+  readFile(path) {
+    try {
+      return (0, import_node_fs.statSync)(path).isFile() ? (0, import_node_fs.readFileSync)(path, "utf8") : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+};
 
-// src/lib/roblox.ts
-var import_node_fs2 = require("fs");
-var import_node_url2 = require("url");
-var robloxDefsPath = (0, import_node_url2.fileURLToPath)(new URL("./roblox.d.luaut", importMetaUrl));
-var robloxDefs = (0, import_node_fs2.readFileSync)(robloxDefsPath, "utf8");
-var robloxLib = parse(robloxDefs);
+// src/project/config.ts
+var import_node_path = require("path");
+var CONFIG_FILE_NAMES = ["luaut.config.json", "luaut.config.jsonc"];
+function findConfig(file, host = nodeHost) {
+  const searched = [];
+  let directory = (0, import_node_path.dirname)((0, import_node_path.resolve)(file));
+  for (; ; ) {
+    const found = [];
+    for (const name of CONFIG_FILE_NAMES) {
+      const path = (0, import_node_path.join)(directory, name);
+      searched.push(path);
+      if (host.readFile(path) !== void 0) found.push(path);
+    }
+    if (found.length > 1) {
+      const message = `Only one luaut config may be in a folder, but both ${CONFIG_FILE_NAMES.join(" and ")} are in ${directory}`;
+      return { searched, problems: found.map((path) => ({ file: path, message, line: 1, column: 1 })) };
+    }
+    if (found.length === 1) {
+      const { config, problems } = loadConfig(found[0], host);
+      return { config, problems, searched };
+    }
+    const parent = (0, import_node_path.dirname)(directory);
+    if (parent === directory) return { searched, problems: [] };
+    directory = parent;
+  }
+}
+var OPTIONS = ["types", "paths", "baseUrl", "sourceMap"];
+function loadConfig(path, host = nodeHost) {
+  const file = (0, import_node_path.resolve)(path);
+  const source = host.readFile(file);
+  if (source === void 0) return { problems: [{ file, message: "Cannot read the config file" }] };
+  let raw;
+  try {
+    raw = JSON.parse(stripJsonComments(source));
+  } catch (error) {
+    const message = error.message;
+    return { problems: [{ file, message: `Invalid JSON: ${message}`, ...jsonErrorPosition(source, message) }] };
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return { problems: [{ file, message: "The config must be a JSON object", line: 1, column: 1 }] };
+  }
+  const directory = (0, import_node_path.dirname)(file);
+  const options = raw;
+  const problems = [];
+  const at = (key) => keyPosition(source, key);
+  const problem = (key, message) => {
+    problems.push({ file, message, ...at(key) });
+  };
+  for (const key of Object.keys(options)) {
+    if (!OPTIONS.includes(key)) {
+      problem(key, `Unknown option '${key}'. Options are: ${OPTIONS.join(", ")}`);
+    }
+  }
+  let types = [];
+  if (options.types !== void 0) {
+    if (Array.isArray(options.types) && options.types.every((t) => typeof t === "string")) types = options.types;
+    else problem("types", `'types' must be an array of strings, such as ["luau"]`);
+  }
+  const paths = {};
+  if (options.paths !== void 0) {
+    const value = options.paths;
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      for (const [pattern, targets] of Object.entries(value)) {
+        if (Array.isArray(targets) && targets.every((t) => typeof t === "string")) paths[pattern] = targets;
+        else problem(pattern, `'paths' entry '${pattern}' must be an array of strings`);
+        if (pattern.split("*").length > 2) problem(pattern, `'paths' pattern '${pattern}' may contain at most one '*'`);
+      }
+    } else {
+      problem("paths", `'paths' must be an object, such as { "@shared/*": ["src/shared/*"] }`);
+    }
+  }
+  let baseUrl = directory;
+  if (options.baseUrl !== void 0) {
+    if (typeof options.baseUrl === "string") baseUrl = (0, import_node_path.resolve)(directory, options.baseUrl);
+    else problem("baseUrl", "'baseUrl' must be a string");
+  }
+  let sourceMap = null;
+  if (options.sourceMap !== void 0 && options.sourceMap !== null) {
+    if (typeof options.sourceMap === "string") sourceMap = (0, import_node_path.resolve)(directory, options.sourceMap);
+    else problem("sourceMap", "'sourceMap' must be a path string, or null for none");
+  }
+  return { config: { path: file, directory, source, types, paths, baseUrl, sourceMap }, problems };
+}
+function stripJsonComments(text) {
+  const out = text.split("");
+  let i = 0;
+  let inString = false;
+  while (i < text.length) {
+    const ch = text[i];
+    if (inString) {
+      if (ch === "\\") i += 2;
+      else {
+        if (ch === '"') inString = false;
+        i++;
+      }
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      i++;
+    } else if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") out[i++] = " ";
+    } else if (ch === "/" && text[i + 1] === "*") {
+      out[i++] = " ";
+      out[i++] = " ";
+      while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) {
+        if (text[i] !== "\n") out[i] = " ";
+        i++;
+      }
+      if (i < text.length) {
+        out[i++] = " ";
+        out[i++] = " ";
+      }
+    } else if (ch === ",") {
+      let j = i + 1;
+      while (j < text.length && /\s/.test(text[j])) j++;
+      if (text[j] === "}" || text[j] === "]") out[i] = " ";
+      i++;
+    } else {
+      i++;
+    }
+  }
+  return out.join("");
+}
+function jsonErrorPosition(source, message) {
+  const lineColumn = /line (\d+) column (\d+)/.exec(message);
+  if (lineColumn) return { line: Number(lineColumn[1]), column: Number(lineColumn[2]) };
+  const position = /position (\d+)/.exec(message);
+  return position ? offsetPosition(source, Number(position[1])) : { line: 1, column: 1 };
+}
+function keyPosition(source, key) {
+  const offset = source.indexOf(JSON.stringify(key));
+  return offset < 0 ? { line: 1, column: 1 } : offsetPosition(source, offset);
+}
+function offsetPosition(source, offset) {
+  const before = source.slice(0, offset);
+  const line = before.split("\n").length;
+  return { line, column: offset - before.lastIndexOf("\n") };
+}
+
+// src/project/libraries.ts
+var import_node_path2 = require("path");
+function resolveTypeLibraries(config, host = nodeHost) {
+  const files = [];
+  const problems = [];
+  const loaded = /* @__PURE__ */ new Set();
+  const addFile = (file) => {
+    const key = pathKey(file);
+    if (loaded.has(key)) return;
+    loaded.add(key);
+    files.push(file);
+  };
+  const addPackage = (directory, entryFile, visiting) => {
+    const key = pathKey(directory);
+    if (visiting.has(key)) return;
+    visiting.add(key);
+    for (const dependency of dependencyNames(directory, host)) {
+      const found = findPackage(dependency, directory, host);
+      if (found) addPackage(found.directory, found.file, visiting);
+    }
+    addFile(entryFile);
+  };
+  for (const entry of config.types) {
+    const relative = entry.startsWith("./") || entry.startsWith("../") || entry.startsWith("/") || /^[A-Za-z]:[\\/]/.test(entry);
+    if (relative) {
+      const target = (0, import_node_path2.resolve)(config.directory, entry);
+      if (entry.endsWith(".luaut")) {
+        if (host.readFile(target) !== void 0) addFile(target);
+        else problems.push({ file: config.path, message: `Cannot find type library file '${entry}'`, ...entryPosition(config, entry) });
+        continue;
+      }
+      const file = packageEntry(target, host);
+      if (file) addPackage(target, file, /* @__PURE__ */ new Set());
+      else problems.push({ file: config.path, message: `'${entry}' has no ${ENTRY_FILE} (or 'luaut.types' in its package.json)`, ...entryPosition(config, entry) });
+      continue;
+    }
+    const names = entry.startsWith("@") || entry.includes("/") ? [entry] : [`@luaut/${entry}`, entry];
+    const found = names.map((name) => findPackage(name, config.directory, host)).find(Boolean);
+    if (found) addPackage(found.directory, found.file, /* @__PURE__ */ new Set());
+    else {
+      problems.push({
+        file: config.path,
+        message: `Cannot find type library '${entry}'. Install it with: npm i -D ${names[0]}`,
+        ...entryPosition(config, entry)
+      });
+    }
+  }
+  return { files, problems };
+}
+var ENTRY_FILE = "index.d.luaut";
+function packageEntry(directory, host) {
+  const manifest = readJson((0, import_node_path2.join)(directory, "package.json"), host);
+  const declared = manifest?.luaut?.types;
+  const file = (0, import_node_path2.resolve)(directory, typeof declared === "string" ? declared : ENTRY_FILE);
+  return host.readFile(file) !== void 0 ? file : void 0;
+}
+function findPackage(name, from, host) {
+  let directory = (0, import_node_path2.resolve)(from);
+  for (; ; ) {
+    const candidate = (0, import_node_path2.join)(directory, "node_modules", ...name.split("/"));
+    const file = packageEntry(candidate, host);
+    if (file) return { directory: candidate, file };
+    const parent = (0, import_node_path2.dirname)(directory);
+    if (parent === directory) return void 0;
+    directory = parent;
+  }
+}
+function dependencyNames(directory, host) {
+  const manifest = readJson((0, import_node_path2.join)(directory, "package.json"), host);
+  const names = /* @__PURE__ */ new Set();
+  for (const field of ["dependencies", "peerDependencies"]) {
+    const deps = manifest?.[field];
+    if (deps && typeof deps === "object") for (const name of Object.keys(deps)) names.add(name);
+  }
+  return [...names];
+}
+function readJson(path, host) {
+  const text = host.readFile(path);
+  if (text === void 0) return void 0;
+  try {
+    const value = JSON.parse(text);
+    return value && typeof value === "object" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function entryPosition(config, entry) {
+  return keyPosition(config.source, entry);
+}
+function pathKey(path) {
+  const normalized = (0, import_node_path2.resolve)(path);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
+
+// src/project/modules.ts
+var import_node_path3 = require("path");
+function moduleCandidates(fromFile, specifier, config) {
+  const bases = specifier.startsWith("./") || specifier.startsWith("../") ? [(0, import_node_path3.resolve)((0, import_node_path3.dirname)(fromFile), specifier)] : config ? aliasTargets(config, specifier) : [];
+  return bases.flatMap((base) => base.endsWith(".luaut") ? [base] : [`${base}.luaut`, `${base}.d.luaut`, (0, import_node_path3.join)(base, "index.luaut")]);
+}
+function resolveModulePath(fromFile, specifier, config, host = nodeHost) {
+  return moduleCandidates(fromFile, specifier, config).find((path) => host.readFile(path) !== void 0);
+}
+function aliasTargets(config, specifier) {
+  let match;
+  let prefixLength = -1;
+  for (const pattern2 of Object.keys(config.paths)) {
+    const star = pattern2.indexOf("*");
+    if (star < 0) {
+      if (pattern2 === specifier) {
+        match = { pattern: pattern2, wildcard: "" };
+        break;
+      }
+      continue;
+    }
+    const prefix = pattern2.slice(0, star);
+    const suffix = pattern2.slice(star + 1);
+    const fits = specifier.length >= prefix.length + suffix.length && specifier.startsWith(prefix) && specifier.endsWith(suffix);
+    if (fits && prefix.length > prefixLength) {
+      prefixLength = prefix.length;
+      match = { pattern: pattern2, wildcard: specifier.slice(prefix.length, specifier.length - suffix.length) };
+    }
+  }
+  if (!match) return [];
+  const { pattern, wildcard } = match;
+  return config.paths[pattern].map((target) => (0, import_node_path3.resolve)(config.baseUrl, target.replace("*", wildcard)));
+}
+
+// src/project/sourcemap.ts
+var import_node_path4 = require("path");
+var IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var INSTANCE_MEMBERS = /* @__PURE__ */ new Set(["Name", "ClassName", "Parent", "Archivable"]);
+var SCRIPT_EXTENSIONS = /* @__PURE__ */ new Set([".luaut", ".luau", ".lua"]);
+function sourceMapTypes(text, path, options) {
+  let root;
+  try {
+    root = JSON.parse(text);
+  } catch (error) {
+    return { problem: `Invalid sourcemap: ${error.message}` };
+  }
+  if (!isNode(root)) return { problem: "Invalid sourcemap: the root must be an object with 'name' and 'className'" };
+  const directory = (0, import_node_path4.dirname)((0, import_node_path4.resolve)(path));
+  const lines = [];
+  const aliasOfFile = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  const canOmit = options.classes.has("Omit");
+  const aliasOfNode = /* @__PURE__ */ new Map();
+  const aliasFor = (segments) => {
+    const base = `SourceMap_${segments.map((s) => s.replace(/[^A-Za-z0-9_]/g, "_")).join("_")}`;
+    let alias = base;
+    for (let n = 2; used.has(alias); n++) alias = `${base}_${n}`;
+    used.add(alias);
+    return alias;
+  };
+  const visit = (node, segments, parent) => {
+    const alias = aliasFor(segments);
+    aliasOfNode.set(node, alias);
+    for (const filePath of node.filePaths ?? []) aliasOfFile.set(fileKey((0, import_node_path4.resolve)(directory, filePath)), alias);
+    const className = IDENTIFIER.test(node.className) && options.classes.has(node.className) ? node.className : "Instance";
+    const taken = options.membersOf?.(className) ?? INSTANCE_MEMBERS;
+    const members = [];
+    if (parent && canOmit) members.push(`Parent: ${parent}`);
+    const named = /* @__PURE__ */ new Set();
+    for (const child of node.children ?? []) {
+      if (!isNode(child)) continue;
+      const childAlias = visit(child, [...segments, child.name], alias);
+      if (!IDENTIFIER.test(child.name) || taken.has(child.name) || named.has(child.name)) continue;
+      named.add(child.name);
+      members.push(`${child.name}: ${childAlias}`);
+    }
+    const base = parent && canOmit ? `Omit<${className}, "Parent">` : className;
+    lines.push(`type ${alias} = ${members.length ? `${base} & { ${members.join(", ")} }` : base}`);
+    return alias;
+  };
+  const rootAlias = visit(root, [root.name], void 0);
+  if (root.className === "DataModel") {
+    lines.push(`declare game: ${rootAlias}`);
+    const workspace = (root.children ?? []).find((child) => isNode(child) && child.className === "Workspace");
+    const workspaceAlias = workspace && aliasOfNode.get(workspace);
+    if (workspaceAlias) lines.push(`declare workspace: ${workspaceAlias}`);
+  }
+  let program;
+  try {
+    program = parse(lines.join("\n"));
+  } catch (error) {
+    return { problem: `Could not turn the sourcemap into types: ${error.message}` };
+  }
+  return {
+    types: {
+      program,
+      scriptFor(file) {
+        const alias = aliasOfFile.get(fileKey(file));
+        return alias ? parse(`declare script: ${alias}`) : void 0;
+      }
+    }
+  };
+}
+function isNode(value) {
+  if (!value || typeof value !== "object") return false;
+  const node = value;
+  return typeof node.name === "string" && typeof node.className === "string";
+}
+function fileKey(path) {
+  const extension = (0, import_node_path4.extname)(path);
+  const bare = SCRIPT_EXTENSIONS.has(extension) ? path.slice(0, -extension.length) : path;
+  const normalized = (0, import_node_path4.resolve)(bare);
+  return process.platform === "win32" ? normalized.toLowerCase() : normalized;
+}
 
 // src/index.ts
-var defaultLibs = [luauLib, robloxLib];
 var luautparser = {
   tokenize,
   parseTokens,
@@ -5872,6 +6330,7 @@ var index_default = luautparser;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BinaryOperators,
+  CONFIG_FILE_NAMES,
   Keywords,
   LexError,
   Operators,
@@ -5885,10 +6344,10 @@ var index_default = luautparser;
   booleanType,
   bufferType,
   containsTypeParam,
-  defaultLibs,
   difference,
   equalTypes,
   falsyType,
+  findConfig,
   fn,
   formatType,
   getBinding,
@@ -5899,11 +6358,10 @@ var index_default = luautparser;
   isPossiblyTruthy,
   isUnassignedGlobal,
   literal,
-  luauDefs,
-  luauDefsPath,
-  luauLib,
+  loadConfig,
   luautparser,
   matchInfer,
+  moduleCandidates,
   moduleExports,
   narrowExclude,
   narrowFalsy,
@@ -5911,6 +6369,7 @@ var index_default = luautparser;
   narrowTruthy,
   neverType,
   nilType,
+  nodeHost,
   numberType,
   objectType,
   optional,
@@ -5920,11 +6379,12 @@ var index_default = luautparser;
   parseTokens,
   parseWithRecovery,
   primitive,
-  robloxDefs,
-  robloxDefsPath,
-  robloxLib,
+  resolveModulePath,
+  resolveTypeLibraries,
   setAliasExpander,
+  sourceMapTypes,
   stringType,
+  stripJsonComments,
   substitute,
   templateMatches,
   threadType,