@litsx/typescript 0.6.0

package/dist/typecheck.cjs

@@ -0,0 +1,931 @@
+'use strict';
+
+var url = require('url');
+var path = require('path');
+var ts = require('typescript');
+var module$1 = require('module');
+var virtualization = require('./virtualization.cjs');
+var authoredSemantics = require('./authored-semantics.cjs');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const PROJECT_SESSION_CACHE = new Map();
+const SESSION_CACHE_LIMIT = 50;
+const EXTRA_FILE_EXTENSIONS = [
+  {
+    extension: ".litsx",
+    isMixedContent: false,
+    scriptKind: 4,
+  },
+  {
+    extension: ".litsx.jsx",
+    isMixedContent: false,
+    scriptKind: 2,
+  },
+];
+(() => {
+  try {
+    return module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('typecheck.cjs', document.baseURI).href)));
+  } catch {
+    return null;
+  }
+})();
+
+function trimCacheToLimit$1(cache, limit) {
+  while (cache.size > limit) {
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey == null) break;
+    cache.delete(oldestKey);
+  }
+}
+
+function normalizeFilePath(value) {
+  if (!value) return "";
+  return String(value).replace(/\\/g, "/").replace(/\/+/g, "/");
+}
+
+function inferScriptKind(ts, filePath) {
+  const normalized = normalizeFilePath(filePath);
+
+  if (normalized.endsWith(".litsx")) {
+    return ts.ScriptKind.TSX;
+  }
+
+  if (normalized.endsWith(".litsx.jsx")) {
+    return ts.ScriptKind.JSX;
+  }
+
+  if (normalized.endsWith(".tsx")) {
+    return ts.ScriptKind.TSX;
+  }
+
+  if (normalized.endsWith(".jsx")) {
+    return ts.ScriptKind.JSX;
+  }
+
+  if (normalized.endsWith(".ts")) {
+    return ts.ScriptKind.TS;
+  }
+
+  if (normalized.endsWith(".js")) {
+    return ts.ScriptKind.JS;
+  }
+
+  return undefined;
+}
+
+function createSourceTextCache() {
+  return new Map();
+}
+
+function createSourceFileCache() {
+  return new Map();
+}
+
+function createSessionBase({
+  kind,
+  key,
+  typescript,
+}) {
+  return {
+    kind,
+    key,
+    typescript,
+    host: null,
+    hostConfigKey: null,
+    program: null,
+    programKey: null,
+    overlayFiles: new Map(),
+    semanticCaches: new Map(),
+    sourceTextCache: createSourceTextCache(),
+    sourceFileCache: createSourceFileCache(),
+    invalidate({ host = false } = {}) {
+      this.program = null;
+      this.programKey = null;
+      this.semanticCaches.clear();
+      if (host) {
+        this.host = null;
+        this.hostConfigKey = null;
+        this.sourceTextCache.clear();
+        this.sourceFileCache.clear();
+      }
+    },
+    getSemanticCache(name, factory = () => new Map()) {
+      if (!this.semanticCaches.has(name)) {
+        this.semanticCaches.set(name, factory());
+      }
+      return this.semanticCaches.get(name);
+    },
+    setOverlayFile(fileName, sourceText) {
+      this.overlayFiles.set(normalizeFilePath(fileName), sourceText);
+    },
+    clearOverlayFile(fileName) {
+      this.overlayFiles.delete(normalizeFilePath(fileName));
+    },
+    clearOverlayFiles() {
+      this.overlayFiles.clear();
+    },
+  };
+}
+
+function getCachedSourceText(session, fileName, sourceText, transformKey, transform) {
+  const normalizedFileName = normalizeFilePath(fileName);
+  const cacheKey = `${normalizedFileName}:${transformKey}`;
+  const cached = session.sourceTextCache.get(cacheKey);
+  if (cached?.sourceText === sourceText) {
+    return cached.transformedText;
+  }
+  const transformedText = transform ? transform(fileName, sourceText) : sourceText;
+  session.sourceTextCache.set(cacheKey, {
+    sourceText,
+    transformedText,
+  });
+  return transformedText;
+}
+
+function getCachedSourceFile(session, fileName, sourceText, languageVersion, scriptKind, transformKey, transform) {
+  const normalizedFileName = normalizeFilePath(fileName);
+  const transformedText = getCachedSourceText(
+    session,
+    fileName,
+    sourceText,
+    transformKey,
+    transform,
+  );
+  const cacheKey = `${normalizedFileName}:${String(languageVersion)}:${String(scriptKind ?? "")}:${transformKey}`;
+  let fileCache = session.sourceFileCache.get(cacheKey);
+  if (!fileCache) {
+    fileCache = new Map();
+    session.sourceFileCache.set(cacheKey, fileCache);
+  }
+
+  const cachedSourceFile = fileCache.get(sourceText);
+  if (cachedSourceFile) {
+    return cachedSourceFile;
+  }
+
+  const sourceFile = session.typescript.createSourceFile(
+    fileName,
+    transformedText,
+    languageVersion,
+    true,
+    scriptKind ?? inferScriptKind(session.typescript, fileName),
+  );
+  fileCache.set(sourceText, sourceFile);
+  return sourceFile;
+}
+
+function attachSourceFileVersion(sourceFile, version) {
+  if (!sourceFile || typeof sourceFile !== "object") {
+    return sourceFile;
+  }
+
+  if (sourceFile.version == null) {
+    sourceFile.version = version;
+  }
+
+  return sourceFile;
+}
+
+function createProjectHost(session, config) {
+  const ts = session.typescript;
+  const host =
+    typeof ts.createIncrementalCompilerHost === "function"
+      ? ts.createIncrementalCompilerHost(config.parsedCommandLine.options)
+      : ts.createCompilerHost(config.parsedCommandLine.options);
+  const originalReadFile = host.readFile.bind(host);
+  const originalGetSourceFile = host.getSourceFile.bind(host);
+  host.extraFileExtensions = EXTRA_FILE_EXTENSIONS;
+
+  if (typeof host.useCaseSensitiveFileNames !== "function") {
+    host.useCaseSensitiveFileNames = () => ts.sys.useCaseSensitiveFileNames;
+  }
+
+  session.readFile = (fileName) => originalReadFile(fileName);
+
+  host.readFile = (fileName) => {
+    const normalizedFileName = normalizeFilePath(fileName);
+    if (session.overlayFiles.has(normalizedFileName)) {
+      return session.overlayFiles.get(normalizedFileName);
+    }
+
+    const sourceText = originalReadFile(fileName);
+    if (typeof sourceText !== "string") {
+      return sourceText;
+    }
+
+    return getCachedSourceText(session, fileName, sourceText, "project", null);
+  };
+
+  host.getSourceFile = (
+    fileName,
+    languageVersion,
+    onError,
+    shouldCreateNewSourceFile,
+    scriptKind,
+  ) => {
+    const normalizedFileName = normalizeFilePath(fileName);
+    if (session.overlayFiles.has(normalizedFileName)) {
+      const sourceText = session.overlayFiles.get(normalizedFileName);
+      return attachSourceFileVersion(
+        getCachedSourceFile(
+          session,
+          fileName,
+          sourceText,
+          languageVersion,
+          scriptKind,
+          "overlay",
+          null,
+        ),
+        sourceText,
+      );
+    }
+
+    const sourceText = originalReadFile(fileName);
+    if (typeof sourceText !== "string") {
+      return attachSourceFileVersion(
+        originalGetSourceFile(
+          fileName,
+          languageVersion,
+          onError,
+          shouldCreateNewSourceFile,
+          scriptKind,
+        ),
+        "",
+      );
+    }
+
+    return attachSourceFileVersion(
+      getCachedSourceFile(
+        session,
+        fileName,
+        sourceText,
+        languageVersion,
+        scriptKind,
+        "project",
+        null,
+      ),
+      sourceText,
+    );
+  };
+
+  return host;
+}
+
+function createProjectProgramKey(parsedCommandLine) {
+  return JSON.stringify({
+    options: parsedCommandLine.options,
+    fileNames: parsedCommandLine.fileNames,
+    projectReferences: parsedCommandLine.projectReferences?.map((reference) => reference.path),
+    projectVersion: parsedCommandLine.projectVersion,
+  });
+}
+
+function createProjectHostKey(config) {
+  return JSON.stringify({
+    options: config.parsedCommandLine.options,
+    fileNames: config.parsedCommandLine.fileNames,
+    projectReferences: config.parsedCommandLine.projectReferences?.map((reference) => reference.path),
+  });
+}
+
+function attachProjectSessionMethods(session, config) {
+  function ensureHost() {
+    const hostKey = createProjectHostKey(config);
+    if (!session.host || session.hostConfigKey !== hostKey) {
+      session.host = createProjectHost(session, config);
+      session.hostConfigKey = hostKey;
+      session.program = null;
+      session.programKey = null;
+      session.semanticCaches.clear();
+    }
+    return session.host;
+  }
+
+  session.refresh = (nextConfig = {}) => {
+    config = {
+      ...config,
+      ...nextConfig,
+    };
+    ensureHost();
+    return session;
+  };
+
+  session.getProgram = () => {
+    const programKey = createProjectProgramKey(config.parsedCommandLine);
+    ensureHost();
+
+    const builderProgram =
+      session.program &&
+      typeof session.typescript.createIncrementalProgram === "function"
+        ? session.typescript.createIncrementalProgram({
+          rootNames: config.parsedCommandLine.fileNames,
+          options: config.parsedCommandLine.options,
+          projectReferences: config.parsedCommandLine.projectReferences,
+          host: session.host,
+          oldProgram: session.program,
+        })
+        : null;
+
+    const program = builderProgram
+      ? (typeof builderProgram.getProgram === "function"
+          ? builderProgram.getProgram()
+          : builderProgram)
+      : session.typescript.createProgram({
+          rootNames: config.parsedCommandLine.fileNames,
+          options: config.parsedCommandLine.options,
+          projectReferences: config.parsedCommandLine.projectReferences,
+          host: session.host,
+        });
+
+    if (session.program !== program) {
+      session.semanticCaches.clear();
+    }
+    session.program = program;
+    session.programKey = programKey;
+    return program;
+  };
+}
+function attachCommonSessionMethods(session) {
+  session.getChecker = (...args) => session.getProgram(...args).getTypeChecker();
+  session.getSourceFile = (fileName, ...args) => session.getProgram(...args).getSourceFile(fileName);
+  session.getTypeResolver = (fileName, sourceText) => {
+    session.setOverlayFile(fileName, sourceText);
+    const program =
+      session.kind === "project"
+        ? session.getProgram()
+        : session.kind === "standalone"
+          ? session.getProgram(fileName)
+          : session.getProgram(sourceText);
+    const sourceFile = program.getSourceFile(fileName);
+    if (!sourceFile) {
+      session.clearOverlayFile(fileName);
+      return null;
+    }
+    return {
+      filename: normalizeFilePath(fileName),
+      sourceFile,
+      checker: program.getTypeChecker(),
+      program,
+      getSemanticCache(name, factory) {
+        return session.getSemanticCache(name, factory);
+      },
+    };
+  };
+}
+
+function createProjectTsSession(config) {
+  const session = createSessionBase({
+    kind: "project",
+    key: config.sessionKey,
+    typescript: config.typescript,
+  });
+  attachProjectSessionMethods(session, config);
+  attachCommonSessionMethods(session);
+  return session;
+}
+
+function getOrCreateProjectTsSession(key, config) {
+  const cached = PROJECT_SESSION_CACHE.get(key);
+  if (cached) {
+    PROJECT_SESSION_CACHE.delete(key);
+    PROJECT_SESSION_CACHE.set(key, cached);
+    cached.refresh(config);
+    return cached;
+  }
+
+  const session = createProjectTsSession({
+    ...config,
+    sessionKey: key,
+  });
+  PROJECT_SESSION_CACHE.set(key, session);
+  trimCacheToLimit$1(PROJECT_SESSION_CACHE, SESSION_CACHE_LIMIT);
+  return session;
+}
+
+const PROFILE_ENABLED = process.env.LITSX_PROFILE === "1";
+const PARSED_COMMAND_LINE_CACHE = new Map();
+const TYPECHECK_SESSION_BY_PROJECT = new Map();
+const TYPECHECK_SESSION_CACHE_LIMIT = 20;
+const FORMAT_HOST = createFormatHost();
+const LITSX_EXTRA_FILE_EXTENSIONS = [
+  {
+    extension: ".litsx",
+    isMixedContent: false,
+    scriptKind: ts.ScriptKind.TSX,
+  },
+  {
+    extension: ".litsx.jsx",
+    isMixedContent: false,
+    scriptKind: ts.ScriptKind.JSX,
+  },
+];
+
+function profilePhase(namespace, name, callback) {
+  if (!PROFILE_ENABLED) {
+    return callback();
+  }
+
+  const start = performance.now();
+  try {
+    return callback();
+  } finally {
+    globalThis.__litsxProfileEvents ??= [];
+    globalThis.__litsxProfileEvents.push({
+      namespace,
+      name,
+      durationMs: performance.now() - start,
+    });
+  }
+}
+
+function isRelevantFile(fileName) {
+  return /\.(jsx|tsx|litsx)$/.test(fileName) || fileName.endsWith(".litsx.jsx");
+}
+
+function getPluginsForFile(fileName) {
+  return (fileName.endsWith(".tsx") || fileName.endsWith(".litsx")) ? ["typescript"] : [];
+}
+
+function getAdditionalLitsxFileNames(tsconfigPath, configJson, basePath) {
+  const configuredFiles = Array.isArray(configJson?.files)
+    ? configJson.files
+        .filter((file) => file.endsWith(".litsx") || file.endsWith(".litsx.jsx"))
+        .map((file) => path.resolve(basePath, file))
+    : [];
+
+  const explicitlyIncludedFiles = Array.isArray(configJson?.include)
+    ? configJson.include
+        .filter((pattern) => pattern.endsWith(".litsx") || pattern.endsWith(".litsx.jsx"))
+        .map((pattern) => path.resolve(basePath, pattern))
+        .filter((fileName) => ts.sys.fileExists(fileName))
+    : [];
+
+  const includedFiles = ts.sys.readDirectory(
+    basePath,
+    [".litsx", ".litsx.jsx"],
+    configJson?.exclude,
+    configJson?.include ?? ["**/*"],
+  );
+
+  return [...new Set([...configuredFiles, ...explicitlyIncludedFiles, ...includedFiles])]
+    .filter((fileName) => fileName !== tsconfigPath)
+    .sort();
+}
+
+function trimCacheToLimit(cache, limit) {
+  while (cache.size > limit) {
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey == null) break;
+    cache.delete(oldestKey);
+  }
+}
+
+function getFileVersion(filePath) {
+  try {
+    const stats = ts.sys.getModifiedTime?.(filePath);
+    if (stats instanceof Date) {
+      return String(stats.getTime());
+    }
+  } catch {}
+
+  try {
+    const content = ts.sys.readFile(filePath);
+    return typeof content === "string" ? String(content.length) : null;
+  } catch {
+    return null;
+  }
+}
+
+function createNormalizedArgKey(rawArgs) {
+  return rawArgs.join("\0");
+}
+
+function createSessionKey(projectPath, rawArgs) {
+  return `${projectPath || "<no-project>"}:${createNormalizedArgKey(rawArgs)}`;
+}
+
+function createVirtualizationState() {
+  const cache = new Map();
+  const sourceFileCache = new Map();
+
+  function normalizeFileName(fileName) {
+    return path.resolve(fileName);
+  }
+
+  function get(fileName) {
+    return cache.get(normalizeFileName(fileName)) ?? null;
+  }
+
+  function clear(fileName) {
+    const normalizedFileName = normalizeFileName(fileName);
+    cache.delete(normalizedFileName);
+    sourceFileCache.delete(normalizedFileName);
+  }
+
+  function buildVirtualizationRecord(fileName, sourceText) {
+    const normalizedFileName = normalizeFileName(fileName);
+    const cachedRecord = cache.get(normalizedFileName) ?? null;
+
+    if (cachedRecord?.sourceText === sourceText) {
+      return cachedRecord;
+    }
+
+    if (!isRelevantFile(fileName) || !authoredSemantics.looksLikeLitsxJsx(sourceText)) {
+      clear(fileName);
+      return null;
+    }
+
+    const parserPlugins = getPluginsForFile(fileName);
+    const virtualization$1 = profilePhase(
+      "typescript-typecheck",
+      "tooling-virtualization",
+      () => virtualization.createToolingVirtualLitsxSource(sourceText, {
+        plugins: parserPlugins,
+      }),
+    );
+
+    if (virtualization$1.code === sourceText) {
+      clear(fileName);
+      return null;
+    }
+
+    const record = {
+      ...virtualization$1,
+      sourceText,
+      parserPlugins,
+      virtualizedText: virtualization$1.code,
+    };
+    cache.set(normalizedFileName, record);
+    return record;
+  }
+
+  return {
+    get,
+    getOrBuild(fileName, sourceText) {
+      return buildVirtualizationRecord(fileName, sourceText);
+    },
+    getVirtualizedText(fileName, sourceText) {
+      const virtualization = buildVirtualizationRecord(fileName, sourceText);
+      return virtualization?.virtualizedText ?? sourceText;
+    },
+    getOrCreateSourceFile(fileName, sourceText, languageVersion, scriptKind) {
+      const normalizedFileName = normalizeFileName(fileName);
+      const virtualizedText = this.getVirtualizedText(fileName, sourceText);
+      const cacheKey = `${String(languageVersion)}:${String(scriptKind ?? "")}:${sourceText}`;
+      let fileCache = sourceFileCache.get(normalizedFileName);
+      if (!fileCache) {
+        fileCache = new Map();
+        sourceFileCache.set(normalizedFileName, fileCache);
+      }
+
+      const cachedSourceFile = fileCache.get(cacheKey);
+      if (cachedSourceFile) {
+        return cachedSourceFile;
+      }
+
+      const sourceFile = ts.createSourceFile(
+        fileName,
+        virtualizedText,
+        languageVersion,
+        true,
+        scriptKind,
+      );
+      fileCache.set(cacheKey, sourceFile);
+      return sourceFile;
+    },
+  };
+}
+
+function remapMessageText(messageText) {
+  if (typeof messageText === "string") {
+    return authoredSemantics.remapVirtualText(messageText);
+  }
+
+  if (!messageText || typeof messageText !== "object") {
+    return messageText;
+  }
+
+  return {
+    ...messageText,
+    messageText: remapMessageText(messageText.messageText),
+    next: messageText.next?.map(remapMessageText),
+  };
+}
+
+function remapDiagnostic(diagnostic, virtualizationState) {
+  const fileName = diagnostic.file?.fileName;
+  const virtualization$1 = fileName ? virtualizationState.get(fileName) : null;
+
+  if (!virtualization$1 || typeof diagnostic.start !== "number") {
+    return {
+      ...diagnostic,
+      messageText: remapMessageText(diagnostic.messageText),
+    };
+  }
+
+  const remappedSpan = virtualization.remapToolingTextSpanToOriginal(
+    {
+      start: diagnostic.start,
+      length: diagnostic.length ?? 0,
+    },
+    virtualization$1,
+  );
+
+  return {
+    ...diagnostic,
+    start: remappedSpan.start,
+    length: remappedSpan.length,
+    messageText: remapMessageText(diagnostic.messageText),
+    relatedInformation: diagnostic.relatedInformation?.map((info) => {
+      if (!info.file || typeof info.start !== "number") {
+        return {
+          ...info,
+          messageText: remapMessageText(info.messageText),
+        };
+      }
+
+      const infoVirtualization = virtualizationState.get(info.file.fileName);
+      if (!infoVirtualization) {
+        return {
+          ...info,
+          messageText: remapMessageText(info.messageText),
+        };
+      }
+
+      const infoSpan = virtualization.remapToolingTextSpanToOriginal(
+        {
+          start: info.start,
+          length: info.length ?? 0,
+        },
+        infoVirtualization,
+      );
+
+      return {
+        ...info,
+        start: infoSpan.start,
+        length: infoSpan.length,
+        messageText: remapMessageText(info.messageText),
+      };
+    }),
+  };
+}
+
+function createFormatHost() {
+  return {
+    getCanonicalFileName(fileName) {
+      return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+    },
+    getCurrentDirectory() {
+      return ts.sys.getCurrentDirectory();
+    },
+    getNewLine() {
+      return ts.sys.newLine;
+    },
+  };
+}
+
+function resolveParsedCommandLine(rawArgs) {
+  const parsedCommandLine = ts.parseCommandLine(rawArgs);
+
+  if (parsedCommandLine.errors.length > 0) {
+    return parsedCommandLine;
+  }
+
+  const projectPath = parsedCommandLine.options.project
+    ? path.resolve(parsedCommandLine.options.project)
+    : ts.findConfigFile(process.cwd(), ts.sys.fileExists, "tsconfig.json");
+
+  if (!projectPath) {
+    return {
+      ...parsedCommandLine,
+      errors: [
+        {
+          category: ts.DiagnosticCategory.Error,
+          code: 5083,
+          file: undefined,
+          start: undefined,
+          length: undefined,
+          messageText: "Cannot find a tsconfig.json file.",
+        },
+      ],
+    };
+  }
+
+  const configFile = ts.readConfigFile(projectPath, ts.sys.readFile);
+  if (configFile.error) {
+    return {
+      ...parsedCommandLine,
+      errors: [configFile.error],
+    };
+  }
+
+  const configHost = {
+    ...ts.sys,
+    onUnRecoverableConfigFileDiagnostic() {},
+  };
+  const projectVersion = getFileVersion(projectPath) ?? "unknown";
+  const cacheKey = `${projectPath}:${projectVersion}:${createNormalizedArgKey(rawArgs)}`;
+  const cached = PARSED_COMMAND_LINE_CACHE.get(cacheKey);
+  if (cached) {
+    PARSED_COMMAND_LINE_CACHE.delete(cacheKey);
+    PARSED_COMMAND_LINE_CACHE.set(cacheKey, cached);
+    return cached;
+  }
+
+  const resolved = {
+    ...ts.parseJsonConfigFileContent(
+      configFile.config,
+      configHost,
+      path.dirname(projectPath),
+      parsedCommandLine.options,
+      projectPath,
+      undefined,
+      LITSX_EXTRA_FILE_EXTENSIONS,
+    ),
+    projectPath,
+    projectVersion,
+    __litsxSessionKey: createSessionKey(projectPath, rawArgs),
+  };
+
+  if (!Object.hasOwn(configFile.config?.compilerOptions || {}, "types")) {
+    resolved.options = {
+      ...resolved.options,
+      // Preserve TypeScript 5.x ambient @types loading for litsx-tsc when
+      // projects haven't opted into an explicit `types` list yet.
+      types: ["*"],
+    };
+  }
+
+  resolved.fileNames = [
+    ...new Set([
+      ...resolved.fileNames,
+      ...getAdditionalLitsxFileNames(projectPath, configFile.config, path.dirname(projectPath)),
+    ]),
+  ].sort();
+
+  if (resolved.fileNames.some((fileName) => fileName.endsWith(".litsx") || fileName.endsWith(".litsx.jsx"))) {
+    resolved.options = {
+      ...resolved.options,
+      allowNonTsExtensions: true,
+    };
+  }
+
+  if (resolved.fileNames.length > 0 && Array.isArray(resolved.errors)) {
+    resolved.errors = resolved.errors.filter((error) => error?.code !== 18003);
+  }
+
+  PARSED_COMMAND_LINE_CACHE.set(cacheKey, resolved);
+  trimCacheToLimit(PARSED_COMMAND_LINE_CACHE, TYPECHECK_SESSION_CACHE_LIMIT);
+  return resolved;
+}
+
+function createTypecheckSession(parsedCommandLine, projectSession = null) {
+  const virtualizationState = createVirtualizationState();
+  return {
+    parsedCommandLine,
+    sessionKey: parsedCommandLine.__litsxSessionKey,
+    virtualizationState,
+    diagnosticsCacheKey: null,
+    diagnosticsCacheResult: null,
+    projectSession: projectSession || getOrCreateProjectTsSession(parsedCommandLine.__litsxSessionKey, {
+      typescript: ts,
+      parsedCommandLine,
+    }),
+  };
+}
+
+function getTypecheckSession(parsedCommandLine, projectSession = null) {
+  const sessionKey =
+    parsedCommandLine.__litsxSessionKey ||
+    createSessionKey(parsedCommandLine.projectPath, []);
+  const cached = TYPECHECK_SESSION_BY_PROJECT.get(sessionKey);
+  if (cached) {
+    cached.parsedCommandLine = parsedCommandLine;
+    if (projectSession) {
+      cached.projectSession = projectSession;
+      cached.diagnosticsCacheKey = null;
+      cached.diagnosticsCacheResult = null;
+    }
+    cached.projectSession.refresh({
+      parsedCommandLine,
+    });
+    TYPECHECK_SESSION_BY_PROJECT.delete(sessionKey);
+    TYPECHECK_SESSION_BY_PROJECT.set(sessionKey, cached);
+    return cached;
+  }
+
+  const session = createTypecheckSession(parsedCommandLine, projectSession);
+  TYPECHECK_SESSION_BY_PROJECT.set(sessionKey, session);
+  trimCacheToLimit(TYPECHECK_SESSION_BY_PROJECT, TYPECHECK_SESSION_CACHE_LIMIT);
+  return session;
+}
+
+function createLitsxTypecheckSession(rawArgs = process.argv.slice(2), options = {}) {
+  const parsedCommandLine = resolveParsedCommandLine(rawArgs);
+  return getTypecheckSession(parsedCommandLine, options.projectSession);
+}
+
+function createDiagnosticsCacheKey(session) {
+  const parsedCommandLine = session.parsedCommandLine;
+  const fileVersions = parsedCommandLine.fileNames.map((fileName) => (
+    `${fileName}:${getFileVersion(fileName) ?? "missing"}`
+  ));
+  return `${parsedCommandLine.projectVersion || "unknown"}\0${fileVersions.join("\0")}`;
+}
+
+function runTypecheckSession(session) {
+  const parsedCommandLine = session.parsedCommandLine;
+
+  if (parsedCommandLine.errors?.length) {
+    const output = ts.formatDiagnosticsWithColorAndContext(parsedCommandLine.errors, FORMAT_HOST);
+    if (output) {
+      process.stderr.write(output);
+    }
+    return 1;
+  }
+
+  const virtualizationState = session.virtualizationState;
+  session.projectSession.refresh({
+    parsedCommandLine,
+  });
+  for (const fileName of parsedCommandLine.fileNames) {
+    const sourceText = session.projectSession.readFile?.(fileName) ?? ts.sys.readFile(fileName);
+    if (typeof sourceText !== "string") {
+      session.projectSession.clearOverlayFile(fileName);
+      continue;
+    }
+
+    const virtualizedText = virtualizationState.getVirtualizedText(fileName, sourceText);
+    if (virtualizedText === sourceText) {
+      session.projectSession.clearOverlayFile(fileName);
+      continue;
+    }
+
+    session.projectSession.setOverlayFile(fileName, virtualizedText);
+  }
+
+  const program = profilePhase(
+    "typescript-typecheck",
+    "create-program",
+    () => session.projectSession.getProgram(),
+  );
+
+  const diagnosticsCacheKey = profilePhase(
+    "typescript-typecheck",
+    "diagnostic-cache-key",
+    () => createDiagnosticsCacheKey(session),
+  );
+
+  if (
+    session.diagnosticsCacheKey === diagnosticsCacheKey &&
+    session.diagnosticsCacheResult
+  ) {
+    const cachedResult = session.diagnosticsCacheResult;
+    if (cachedResult.output) {
+      process.stderr.write(cachedResult.output);
+    }
+    return cachedResult.exitCode;
+  }
+
+  const diagnostics = profilePhase(
+    "typescript-typecheck",
+    "diagnostics",
+    () => ts.getPreEmitDiagnostics(program),
+  )
+    .map((diagnostic) => remapDiagnostic(diagnostic, virtualizationState));
+
+  if (diagnostics.length > 0) {
+    const output = ts.formatDiagnosticsWithColorAndContext(diagnostics, FORMAT_HOST);
+    if (output) {
+      process.stderr.write(output);
+    }
+    session.diagnosticsCacheKey = diagnosticsCacheKey;
+    session.diagnosticsCacheResult = {
+      exitCode: 1,
+      output,
+    };
+    return 1;
+  }
+
+  session.diagnosticsCacheKey = diagnosticsCacheKey;
+  session.diagnosticsCacheResult = {
+    exitCode: 0,
+    output: "",
+  };
+  return 0;
+}
+
+function runLitsxTypecheck(rawArgs = process.argv.slice(2)) {
+  const session = Array.isArray(rawArgs)
+    ? createLitsxTypecheckSession(rawArgs)
+    : rawArgs;
+  return runTypecheckSession(session);
+}
+
+if (process.argv[1] && url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('typecheck.cjs', document.baseURI).href))) === path.resolve(process.argv[1])) {
+  process.exitCode = runLitsxTypecheck(process.argv.slice(2));
+}
+
+exports.createLitsxTypecheckSession = createLitsxTypecheckSession;
+exports.runLitsxTypecheck = runLitsxTypecheck;
+//# sourceMappingURL=typecheck.cjs.map