@danielx/civet 0.11.7 → 0.11.8

package/dist/ts-service/index.mjs

@@ -0,0 +1,1188 @@
+// source/ts-service/snapshot.civet
+import ts from "typescript";
+function fullDiffTextChangeRange(oldText, newText) {
+  const oldTextLength = oldText.length;
+  const newTextLength = newText.length;
+  const minLength = Math.min(oldTextLength, newTextLength);
+  for (let start = 0; start < minLength; start++) {
+    if (oldText[start] !== newText[start]) {
+      let end = oldTextLength;
+      let stop = minLength - start;
+      for (let i = 0; i < stop; i++) {
+        if (oldText[oldTextLength - i - 1] !== newText[newTextLength - i - 1]) {
+          break;
+        }
+        end--;
+      }
+      const length = end - start;
+      const newLength = length + (newTextLength - oldTextLength);
+      return {
+        span: { start, length },
+        newLength
+      };
+    }
+  }
+  return void 0;
+}
+function Snap(newText) {
+  const changeRanges = /* @__PURE__ */ new Map();
+  const snapshot = {
+    getText: (start, end) => newText.slice(start, end),
+    getLength: () => newText.length,
+    getChangeRange(oldSnapshot) {
+      if (!changeRanges.has(oldSnapshot)) {
+        changeRanges.set(oldSnapshot, void 0);
+        const oldText = oldSnapshot.getText(0, oldSnapshot.getLength());
+        const changeRange = fullDiffTextChangeRange(oldText, newText);
+        if (changeRange) {
+          changeRanges.set(oldSnapshot, changeRange);
+        }
+      }
+      return changeRanges.get(oldSnapshot);
+    }
+  };
+  return snapshot;
+}
+
+// source/ts-service/path.civet
+import ts3 from "typescript";
+import path from "node:path";
+
+// source/ts-service/types.civet
+import ts2 from "typescript";
+
+// source/ts-service/path.civet
+function getCanonicalFileName(fileName) {
+  fileName = path.normalize(fileName);
+  if (!(ts3.sys?.useCaseSensitiveFileNames ?? true)) {
+    fileName = fileName.toLowerCase();
+  }
+  return fileName;
+}
+var lastExtension = /(?:\.(?:[^./]+))?$/;
+var lastTwoExtensions = /(\.[^./]*)(\.[^./]*)$/;
+function getExtensionFromPath(p) {
+  const match = p.match(lastExtension);
+  if (!match) {
+    return "";
+  }
+  return match[0];
+}
+function getTranspiledExtensionsFromPath(p) {
+  const match = p.match(lastTwoExtensions);
+  if (!match) {
+    return;
+  }
+  return [match[1], match[2]];
+}
+function removeExtension(p) {
+  return p.replace(/\.[^\/.]+$/, "");
+}
+function remapFileName(fileName, transpilers) {
+  const [extension, target] = getTranspiledExtensionsFromPath(fileName) ?? [];
+  if (!extension) {
+    return fileName;
+  }
+  const transpiler = transpilers.get(extension);
+  if (!transpiler) {
+    return fileName;
+  }
+  if (transpiler.target === target) {
+    return removeExtension(fileName);
+  }
+  return fileName;
+}
+
+// source/ts-service/host.civet
+import path3 from "node:path";
+import ts5 from "typescript";
+import {} from "typescript";
+
+// source/ts-service/config.civet
+import ts4 from "typescript";
+import path2 from "node:path";
+function buildTranspilers(plugins) {
+  const m = /* @__PURE__ */ new Map();
+  for (const plugin of plugins) {
+    plugin.transpilers?.forEach((t) => {
+      return m.set(t.extension, t);
+    });
+  }
+  return m;
+}
+function mogrifyPackageJsonImports(contents, transpilers) {
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch {
+    return contents;
+  }
+  let ref;
+  if (!((ref = parsed.imports) != null && typeof ref === "object")) {
+    return contents;
+  }
+  let modified = false;
+  function recurse(node) {
+    if (!(node != null && typeof node === "object")) {
+      return;
+    }
+    const obj = node;
+    for (const key in obj) {
+      const value = obj[key];
+      if (typeof value === "string") {
+        const ext = getExtensionFromPath(value);
+        let ref1;
+        if ((ref1 = transpilers.get(ext)) != null) {
+          const t = ref1;
+          obj[key] = value + t.target;
+          modified = true;
+        }
+      } else if (value) {
+        recurse(value);
+      }
+    }
+  }
+  recurse(parsed.imports);
+  if (modified) {
+    return JSON.stringify(parsed);
+  } else return contents;
+}
+function parseTsConfigForCivet(projectPath, transpilers, options = {}) {
+  const widen = options.widenIncludeFilter ?? true;
+  const system = options.system ?? ts4.sys;
+  const extraExtensions = Array.from(transpilers.keys());
+  let ref2;
+  if (widen && extraExtensions.length > 0) {
+    ref2 = {
+      ...system,
+      readDirectory: function(p, extensions, excludes, includes, depth) {
+        const exts = extensions ? [...extensions, ...extraExtensions] : void 0;
+        return system.readDirectory(p, exts, excludes, includes, depth).map((f) => {
+          for (const ext of extraExtensions) {
+            if (f.endsWith(ext)) {
+              const t = transpilers.get(ext);
+              if (t) {
+                return f + t.target;
+              }
+            }
+          }
+          return f;
+        });
+      }
+    };
+  } else ref2 = system;
+  const configSys = ref2;
+  const tsConfigPath = path2.join(projectPath, "tsconfig.json");
+  const config = options.tsConfig ?? ts4.readConfigFile(tsConfigPath, system.readFile).config;
+  const parsed = ts4.parseJsonConfigFileContent(
+    config,
+    configSys,
+    projectPath,
+    {},
+    tsConfigPath,
+    void 0
+  );
+  parsed.options.allowNonTsExtensions ??= true;
+  parsed.options.jsx ??= ts4.JsxEmit.Preserve;
+  parsed.options.rootDir ??= projectPath;
+  return parsed;
+}
+
+// source/ts-service/host.civet
+import assert from "node:assert";
+var { isExternalModuleNameRelative } = ts5;
+function TSHost(compilationSettings, initialFileNames, baseHost, transpilers, docFactory, _logger = console, libDir) {
+  const { rootDir } = compilationSettings;
+  assert(rootDir, "TSHost requires a rootDir in compilationSettings");
+  const scriptFileNames = /* @__PURE__ */ new Map();
+  for (const fileName of initialFileNames) {
+    const scriptFileName = getTranspiledPath(fileName);
+    scriptFileNames.set(getCanonicalFileName(scriptFileName), scriptFileName);
+  }
+  const fileMetaData = /* @__PURE__ */ new Map();
+  const pathMap = /* @__PURE__ */ new Map();
+  const snapshotMap = /* @__PURE__ */ new Map();
+  let projectVersion = 0;
+  const resolutionCache = ts5.createModuleResolutionCache(rootDir, (fileName) => fileName, compilationSettings);
+  const baseReadFile = baseHost.readFile.bind(baseHost);
+  const baseFileExists = baseHost.fileExists.bind(baseHost);
+  const baseDirectoryExists = baseHost.directoryExists?.bind(baseHost) ?? (() => false);
+  let self;
+  return self = Object.assign({}, baseHost, {
+    /** Mogrifies transpilable extensions inside `package.json#imports` on read. */
+    readFile(filename) {
+      const contents = getPathSource(filename);
+      if (contents && path3.basename(filename) === "package.json") {
+        return mogrifyPackageJsonImports(contents, transpilers);
+      }
+      return contents;
+    },
+    /** Treats synthetic `<src>.<target>` siblings as existing whenever the source does. */
+    fileExists(filename) {
+      return pathExists(filename) || syntheticTargetExists(filename);
+    },
+    /**
+     * LSP bundles its own lib copies under `<dist>/lib` (libDir set);
+     * other consumers fall through to TS's resolved-module lookup.
+     */
+    getDefaultLibFileName(options) {
+      if (libDir) {
+        return path3.join(libDir, ts5.getDefaultLibFileName(options));
+      }
+      return baseHost.getDefaultLibFileName(options);
+    },
+    getDefaultLibLocation() {
+      if (libDir) {
+        return libDir;
+      }
+      return baseHost.getDefaultLibLocation?.() ?? path3.dirname(baseHost.getDefaultLibFileName(compilationSettings));
+    },
+    getModuleResolutionCache() {
+      return resolutionCache;
+    },
+    /**
+     * Defer to TS's standard resolver first; fall back to our own walk
+     * (paths / baseUrl / relative) for transpilable extensions TS doesn't
+     * know about.  Requires `allowNonTsExtensions`; matches resolve to a
+     * synthetic `<src>.<target>` so subsequent `getScriptSnapshot` calls
+     * hit the transpiler.
+     */
+    resolveModuleNames(moduleNames, containingFile, _reusedNames, _redirectedReference, compilerOptions, _containingSourceFile) {
+      return moduleNames.map((name) => {
+        const { resolvedModule } = ts5.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache);
+        if (resolvedModule) {
+          return resolvedModule;
+        }
+        const extension = getExtensionFromPath(name);
+        let transpiler = transpilers.get(extension);
+        if (transpiler || !extension) {
+          const exists = transpiler ? pathExists : baseDirectoryExists;
+          const resolvedModule2 = (resolved2) => {
+            if (!transpiler) {
+              for (const [_, t] of transpilers) {
+                const index = path3.join(resolved2, "index" + t.extension);
+                if (pathExists(index)) {
+                  transpiler = t;
+                  resolved2 = index;
+                  break;
+                }
+              }
+              if (!transpiler) {
+                return;
+              }
+            }
+            const { target } = transpiler;
+            return {
+              resolvedFileName: resolved2 + target,
+              extension: target,
+              isExternalLibraryImport: false
+            };
+          };
+          const { paths, pathsBasePath } = compilationSettings;
+          const baseUrl = compilationSettings.baseUrl;
+          if (!isExternalModuleNameRelative(name)) {
+            if (paths) {
+              const pathsBase = baseUrl ?? pathsBasePath;
+              let best = "";
+              let bestPrefix = "";
+              for (const [pattern, replacements] of Object.entries(paths)) {
+                if (pattern.endsWith("*")) {
+                  const prefix = pattern.slice(0, -1);
+                  if (name.startsWith(prefix)) {
+                    for (const replacement of replacements) {
+                      const resolved2 = path3.resolve(
+                        pathsBase,
+                        replacement.replace("*", name.slice(prefix.length))
+                      );
+                      if (exists(resolved2) && prefix.length > bestPrefix.length) {
+                        best = resolved2;
+                        bestPrefix = prefix;
+                      }
+                    }
+                  }
+                } else if (name === pattern) {
+                  for (const replacement of replacements) {
+                    const resolved2 = path3.resolve(pathsBase, replacement);
+                    if (exists(resolved2) && pattern.length > bestPrefix.length) {
+                      best = resolved2;
+                      bestPrefix = pattern;
+                    }
+                  }
+                }
+              }
+              if (best) {
+                return resolvedModule2(best);
+              }
+            }
+            if (baseUrl) {
+              const resolved2 = path3.resolve(baseUrl, name);
+              if (exists(resolved2)) {
+                return resolvedModule2(resolved2);
+              }
+            }
+          } else {
+          }
+          const resolved = path3.resolve(path3.dirname(containingFile), name);
+          if (exists(resolved)) {
+            return resolvedModule2(resolved);
+          }
+        }
+        return void 0;
+      });
+    },
+    resolveModuleNameLiterals(literals, containingFile, _redirectedReference, compilerOptions) {
+      return literals.map((literal) => {
+        const name = literal.text;
+        for (const [ext, t] of transpilers) {
+          if (name.endsWith(ext)) {
+            const resolved = path3.resolve(path3.dirname(containingFile), name);
+            if (pathExists(resolved)) {
+              return {
+                resolvedModule: {
+                  resolvedFileName: resolved + t.target,
+                  extension: t.target,
+                  isExternalLibraryImport: false
+                }
+              };
+            }
+          }
+        }
+        if (!getExtensionFromPath(name)) {
+          const resolved = path3.resolve(path3.dirname(containingFile), name);
+          if (baseDirectoryExists(resolved)) {
+            for (const [_, t] of transpilers) {
+              const index = path3.join(resolved, "index" + t.extension);
+              if (pathExists(index)) {
+                return {
+                  resolvedModule: {
+                    resolvedFileName: index + t.target,
+                    extension: t.target,
+                    isExternalLibraryImport: false
+                  }
+                };
+              }
+            }
+          }
+        }
+        return { resolvedModule: ts5.resolveModuleName(name, containingFile, compilerOptions, self, resolutionCache).resolvedModule };
+      });
+    },
+    addOrUpdateDocument(doc) {
+      const rawPath = path3.normalize(docFactory.uriToPath(doc.uri));
+      const p = getCanonicalFileName(rawPath);
+      snapshotMap.delete(p);
+      projectVersion++;
+      const extension = getExtensionFromPath(p);
+      const transpiler = transpilers.get(extension);
+      if (transpiler) {
+        const { target } = transpiler;
+        const transpiledPath = p + target;
+        const displayTranspiledPath = rawPath + target;
+        let transpiledDoc = pathMap.get(transpiledPath);
+        if (!transpiledDoc) {
+          initTranspiledDoc(displayTranspiledPath);
+        }
+        snapshotMap.delete(transpiledPath);
+        pathMap.set(p, doc);
+        return;
+      }
+      scriptFileNames.set(p, rawPath);
+      pathMap.set(p, doc);
+    },
+    addScriptFileName(p) {
+      const target = getTranspiledPath(p);
+      const canonical = getCanonicalFileName(target);
+      if (scriptFileNames.has(canonical)) {
+        return;
+      }
+      scriptFileNames.set(canonical, target);
+      projectVersion++;
+    },
+    closeDocument(rawPath) {
+      const canonical = getCanonicalFileName(rawPath);
+      const transpiledPath = getCanonicalTranspiledPath(rawPath);
+      pathMap.delete(canonical);
+      snapshotMap.delete(canonical);
+      fileMetaData.delete(canonical);
+      if (transpiledPath !== canonical) {
+        pathMap.delete(transpiledPath);
+        snapshotMap.delete(transpiledPath);
+      }
+      projectVersion++;
+    },
+    removeDocument(rawPath) {
+      const canonical = getCanonicalFileName(rawPath);
+      const transpiledPath = getCanonicalTranspiledPath(rawPath);
+      pathMap.delete(canonical);
+      snapshotMap.delete(canonical);
+      fileMetaData.delete(canonical);
+      scriptFileNames.delete(canonical);
+      if (transpiledPath !== canonical) {
+        pathMap.delete(transpiledPath);
+        snapshotMap.delete(transpiledPath);
+        scriptFileNames.delete(transpiledPath);
+      }
+      projectVersion++;
+    },
+    getMeta(p) {
+      p = getCanonicalFileName(p);
+      getOrCreatePathSnapshot(getCanonicalTranspiledPath(p));
+      return fileMetaData.get(p);
+    },
+    getProjectVersion() {
+      return projectVersion.toString();
+    },
+    getCompilationSettings() {
+      return compilationSettings;
+    },
+    // TS passes forward-slash paths on every OS; both methods
+    // normalize through getCanonicalFileName before lookup.
+    getScriptSnapshot(p) {
+      return getOrCreatePathSnapshot(getCanonicalFileName(p));
+    },
+    getScriptVersion(p) {
+      return pathMap.get(getCanonicalFileName(p))?.version.toString() || "0";
+    },
+    getScriptFileNames() {
+      return Array.from(scriptFileNames.values());
+    },
+    // CompilerHost requires writeFile, but our consumers always pass an
+    // explicit writeFile to program.emit() / builder.emit(), so this is
+    // unreachable — keep as a no-op to satisfy the interface.
+    writeFile(_fileName, _content) {
+      return;
+    }
+  });
+  function syntheticTargetExists(filename) {
+    for (const [ext, t] of transpilers) {
+      if (filename.endsWith(t.target)) {
+        const source = filename.slice(0, -t.target.length);
+        if (source.endsWith(ext) && pathExists(source)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  function pathExists(p) {
+    return pathMap.has(getCanonicalFileName(p)) || baseFileExists(p);
+  }
+  function getPathSource(p) {
+    p = getCanonicalFileName(p);
+    const doc = pathMap.get(p);
+    if (doc) {
+      return doc.getText();
+    }
+    if (baseFileExists(p)) {
+      return baseReadFile(p);
+    }
+    return void 0;
+  }
+  function getTranspiledPath(p) {
+    p = path3.normalize(p);
+    const extension = getExtensionFromPath(p);
+    const transpiler = transpilers.get(extension);
+    if (transpiler) {
+      return p + transpiler.target;
+    }
+    return p;
+  }
+  function getCanonicalTranspiledPath(p) {
+    return getCanonicalFileName(getTranspiledPath(p));
+  }
+  function getOrCreatePathSnapshot(p) {
+    const rawPath = path3.normalize(p);
+    p = getCanonicalFileName(rawPath);
+    let snapshot = snapshotMap.get(p);
+    if (snapshot) {
+      return snapshot;
+    }
+    let transpiler;
+    const exts = getTranspiledExtensionsFromPath(p);
+    if (exts && (transpiler = transpilers.get(exts[0]))) {
+      const sourcePath = removeExtension(p);
+      const sourceDoc = pathMap.get(sourcePath);
+      let transpiledDoc = pathMap.get(p);
+      if (!transpiledDoc) {
+        transpiledDoc = initTranspiledDoc(rawPath);
+      }
+      let source;
+      let sourceDocVersion = 0;
+      if (!sourceDoc) {
+        source = getPathSource(sourcePath);
+      } else {
+        source = sourceDoc.getText();
+        sourceDocVersion = sourceDoc.version;
+      }
+      if (source && sourceDocVersion > transpiledDoc.version) {
+        const transpiledCode = doTranspileAndUpdateMeta(transpiledDoc, sourceDocVersion, transpiler, sourcePath, source);
+        if (transpiledCode != null) {
+          snapshot = Snap(transpiledCode);
+        }
+      }
+      if (!snapshot) {
+        snapshot = Snap(transpiledDoc.getText());
+      }
+      snapshotMap.set(p, snapshot);
+      return snapshot;
+    }
+    snapshot = Snap(getPathSource(p) ?? "");
+    snapshotMap.set(p, snapshot);
+    return snapshot;
+  }
+  function createOrUpdateMeta(p, update) {
+    p = getCanonicalFileName(p);
+    let meta = fileMetaData.get(p);
+    if (!meta) {
+      return fileMetaData.set(p, update);
+    } else {
+      return Object.assign(meta, update);
+    }
+  }
+  function doTranspileAndUpdateMeta(transpiledDoc, version, transpiler, sourcePath, sourceCode) {
+    let result;
+    try {
+      result = transpiler.compile(sourcePath, sourceCode);
+    } catch (e) {
+      createOrUpdateMeta(sourcePath, {
+        transpiledDoc,
+        sourcemapLines: void 0,
+        commentRanges: void 0,
+        parseErrors: [e],
+        fatal: true
+      });
+      return;
+    }
+    if (result instanceof Promise) {
+      return;
+    }
+    if (!result) {
+      return;
+    }
+    const { code: transpiledCode, sourceMap, commentRanges, errors } = result;
+    let sourcemapLines = sourceMap?.lines;
+    sourcemapLines ??= sourceMap?.data?.lines;
+    createOrUpdateMeta(sourcePath, {
+      transpiledDoc,
+      sourcemapLines,
+      commentRanges,
+      parseErrors: errors,
+      fatal: false
+    });
+    docFactory.update(transpiledDoc, transpiledCode, version);
+    return transpiledCode;
+  }
+  function initTranspiledDoc(p) {
+    const scriptPath = path3.normalize(p);
+    p = getCanonicalFileName(scriptPath);
+    const uri = docFactory.pathToUri(scriptPath);
+    const transpiledDoc = docFactory.create(uri, "none", -1, "");
+    pathMap.set(p, transpiledDoc);
+    scriptFileNames.set(p, scriptPath);
+    return transpiledDoc;
+  }
+}
+
+// source/ts-service/service.civet
+import path4 from "node:path";
+import ts6 from "typescript";
+import {} from "typescript";
+var {
+  createCompilerHost,
+  createLanguageService
+} = ts6;
+function TSService(projectPath, options) {
+  const { plugins = [], docFactory, libDir, discoverProjectFiles = true, extraCompilerOptions } = options;
+  const system = options.system ?? ts6.sys;
+  const logger = options.logger ?? console;
+  const transpilers = buildTranspilers(plugins);
+  function registerPlugin(plugin) {
+    plugin.transpilers?.forEach((t) => {
+      return transpilers.set(t.extension, t);
+    });
+  }
+  const parsedConfig = parseTsConfigForCivet(projectPath, transpilers, {
+    tsConfig: options.tsConfig,
+    widenIncludeFilter: discoverProjectFiles,
+    system
+  });
+  let ref;
+  if (extraCompilerOptions) {
+    ref = { ...parsedConfig.options, ...extraCompilerOptions };
+  } else {
+    ref = parsedConfig.options;
+  }
+  ;
+  const hostOptions = ref;
+  const baseHost = createBaseHost(hostOptions, system);
+  const host = TSHost(hostOptions, parsedConfig.fileNames, baseHost, transpilers, docFactory, logger, libDir);
+  const service = createLanguageService(host);
+  const loadPlugins = async function() {
+    const civetFolder = path4.join(projectPath, "./.civet/");
+    let civetFiles;
+    try {
+      civetFiles = system.readDirectory(civetFolder);
+    } catch (e) {
+      logger.info(`No .civet plugin folder at ${civetFolder} (${e.message})`);
+      return;
+    }
+    const pluginFiles = civetFiles.filter((file) => file.endsWith("plugin.mjs"));
+    for (const filePath of pluginFiles) {
+      const pluginUri = docFactory.pathToUri(filePath);
+      logger.info("Loading plugin " + pluginUri);
+      try {
+        const { default: plugin } = await import(
+          /* @vite-ignore */
+          pluginUri
+        );
+        logger.info("Loaded plugin " + plugin);
+        registerPlugin(plugin);
+      } catch (e) {
+        logger.error("Error loading plugin " + pluginUri + " " + e);
+      }
+    }
+    return;
+  };
+  return Object.assign({}, service, {
+    host,
+    /** `foo.civet.tsx` → `foo.civet`; passthrough for non-transpiled files. */
+    getSourceFileName(fileName) {
+      return getCanonicalFileName(remapFileName(fileName, transpilers));
+    },
+    registerPlugin,
+    loadPlugins
+  });
+}
+function createBaseHost(options, system) {
+  if (system === ts6.sys) {
+    return createCompilerHost(options);
+  }
+  const getCanonicalFileName2 = (fileName) => {
+    if (system.useCaseSensitiveFileNames) {
+      return fileName;
+    } else return fileName.toLowerCase();
+  };
+  return {
+    getSourceFile(fileName, languageVersion) {
+      const sourceText = system.readFile(fileName);
+      if (!(sourceText != null)) {
+        return;
+      }
+      return ts6.createSourceFile(fileName, sourceText, languageVersion);
+    },
+    getDefaultLibFileName(options2) {
+      return path4.join("/typescript/lib", ts6.getDefaultLibFileName(options2));
+    },
+    writeFile(fileName, content) {
+      return system.writeFile?.(fileName, content);
+    },
+    getCurrentDirectory() {
+      return system.getCurrentDirectory();
+    },
+    getDirectories(path7) {
+      return system.getDirectories?.(path7) ?? [];
+    },
+    fileExists(fileName) {
+      return system.fileExists(fileName);
+    },
+    readFile(fileName) {
+      return system.readFile(fileName);
+    },
+    useCaseSensitiveFileNames() {
+      return system.useCaseSensitiveFileNames;
+    },
+    getCanonicalFileName: getCanonicalFileName2,
+    getNewLine() {
+      return system.newLine;
+    },
+    directoryExists(path7) {
+      return system.directoryExists?.(path7) ?? false;
+    },
+    readDirectory(path7, extensions, excludes, includes, depth) {
+      return system.readDirectory(path7, extensions, excludes, includes, depth);
+    },
+    realpath(path7) {
+      return system.realpath ? system.realpath(path7) : path7;
+    }
+  };
+}
+
+// source/ts-service/doc.civet
+import { pathToFileURL, fileURLToPath } from "node:url";
+var InMemoryDoc = class {
+  uri;
+  version;
+  text;
+  constructor(uri, version, text) {
+    this.uri = uri;
+    this.version = version;
+    this.text = text;
+  }
+  getText() {
+    return this.text;
+  }
+  setText(t) {
+    this.text = t;
+  }
+};
+function createInMemoryDocFactory() {
+  return {
+    create: (uri, _languageId, version, text) => {
+      return new InMemoryDoc(uri, version, text);
+    },
+    update: (doc, text, version) => {
+      doc.setText(text);
+      return doc.version = version;
+    },
+    uriToPath: (uri) => fileURLToPath(uri),
+    pathToUri: (p) => pathToFileURL(p).toString()
+  };
+}
+
+// source/ts-service/plugins/civet.civet
+import { lib as BundledCivetLib } from "@danielx/civet";
+import BundledCivetModule from "@danielx/civet";
+import BundledCivetPackage from "@danielx/civet/package.json" with { type: "json" };
+import {} from "typescript";
+
+// source/cache.civet
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as path5 from "node:path";
+function hashParts(parts) {
+  const hash = crypto.createHash("sha1");
+  for (const part of parts) {
+    hash.update(part).update("\0");
+  }
+  return hash.digest("hex");
+}
+function stableStringify(value) {
+  return JSON.stringify(value, (_key, val) => {
+    if (typeof val === "function") {
+      return void 0;
+    }
+    if (val && typeof val === "object" && !Array.isArray(val)) {
+      const sorted = {};
+      for (const key of Object.keys(val).sort()) {
+        sorted[key] = val[key];
+      }
+      return sorted;
+    }
+    return val;
+  });
+}
+function makeCacheKey(input) {
+  const resolved = path5.resolve(input.sourcePath).replace(/\\/g, "/");
+  return hashParts([
+    input.source,
+    input.compilerName,
+    input.compilerVersion,
+    input.civetVersion ?? "",
+    input.civetMtime ?? "",
+    resolved,
+    stableStringify(input.options ?? {})
+  ]);
+}
+function createMemoryCache() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      return store.get(key);
+    },
+    set(key, value) {
+      store.set(key, value);
+      return;
+    }
+  };
+}
+function createDiskCache(dir) {
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+  } catch {
+  }
+  return {
+    get(key) {
+      const target = path5.join(dir, key);
+      try {
+        const content = fs.readFileSync(target, "utf8");
+        try {
+          const now = /* @__PURE__ */ new Date();
+          fs.utimesSync(target, now, now);
+        } catch {
+        }
+        return content;
+      } catch {
+        return void 0;
+      }
+    },
+    set(key, value) {
+      const target = path5.join(dir, key);
+      try {
+        const tmp = `${target}.tmp.${process.pid}`;
+        fs.writeFileSync(tmp, value);
+        return fs.renameSync(tmp, target);
+      } catch {
+        return;
+      }
+    }
+  };
+}
+
+// source/ts-service/plugins/civet.civet
+function makeCivetPlugin(options = {}) {
+  const Civet = options.Civet ?? BundledCivetModule;
+  const CivetLib = options.CivetLib ?? BundledCivetLib;
+  const CivetVersion = options.CivetVersion ?? BundledCivetPackage.version;
+  const civetConfig = options.config ?? {};
+  const cache = options.cache;
+  function transpileCivet(p, source) {
+    const errors = [];
+    const options2 = {
+      ...civetConfig,
+      filename: p,
+      errors,
+      sync: true,
+      parseOptions: {
+        ...civetConfig.parseOptions,
+        comptime: false
+      }
+    };
+    const [major, minor, patch] = CivetVersion.split(".").map(Number);
+    if (major === 0 && (minor < 9 || minor === 9 && patch < 4)) {
+      const result = Civet.compile(source, { ...options2, sourceMap: true });
+      return { ...result, errors };
+    }
+    let ref;
+    if (cache) {
+      ref = makeCacheKey({
+        source,
+        sourcePath: p,
+        compilerName: "civet",
+        compilerVersion: CivetVersion,
+        options: civetConfig
+      });
+    } else ref = void 0;
+    const cacheKey = ref;
+    if (cacheKey) {
+      const hit = cache.get(cacheKey);
+      if (hit) {
+        try {
+          const parsed = JSON.parse(hit);
+          const result = {
+            code: parsed.code,
+            sourceMap: { lines: parsed.lines },
+            errors
+          };
+          if (parsed.commentRanges) {
+            result.commentRanges = parsed.commentRanges;
+          }
+          return result;
+        } catch {
+        }
+      }
+    }
+    options2.ast = true;
+    const ast = Civet.compile(source, options2);
+    const sourceMap = new Civet.SourceMap(source, p);
+    const code = Civet.generate(ast, {
+      ...options2,
+      sourceMap
+    });
+    const commentRanges = collectCommentRanges(ast);
+    if (cacheKey && errors.length === 0) {
+      const lines = sourceMap.lines ?? sourceMap.data?.lines;
+      cache.set(cacheKey, JSON.stringify({ code, lines, commentRanges }));
+    }
+    return {
+      code,
+      sourceMap,
+      commentRanges,
+      errors
+    };
+  }
+  function collectCommentRanges(ast) {
+    const comments = CivetLib.gatherRecursiveAll(
+      ast,
+      (node) => {
+        return node?.type === "Comment" && node.$loc?.length > 0;
+      }
+    );
+    return comments.map((comment) => comment.$loc);
+  }
+  return {
+    transpilers: [{
+      extension: ".civet",
+      target: ".tsx",
+      compile: transpileCivet
+    }]
+  };
+}
+
+// source/ts-service/plugins/hera.civet
+import {} from "@danielx/civet";
+import BundledCivetModule2 from "@danielx/civet";
+import BundledCivetPackage2 from "@danielx/civet/package.json" with { type: "json" };
+import { createRequire } from "node:module";
+import {} from "typescript";
+var heraRequire = createRequire(
+  /* c8 ignore start -- one branch fires per build target; tests cover only one */
+  typeof __filename !== "undefined" ? __filename : import.meta.url
+  /* c8 ignore stop */
+);
+function makeHeraPlugin(options = {}) {
+  const Civet = options.Civet ?? BundledCivetModule2;
+  const CivetVersion = options.CivetVersion ?? BundledCivetPackage2.version;
+  const civetConfig = options.config ?? {};
+  const cache = options.cache;
+  let resolvedHera;
+  let resolvedHeraVersion;
+  function getHera() {
+    if (resolvedHera) {
+      return resolvedHera;
+    }
+    if (options.Hera) {
+      resolvedHera = options.Hera;
+      return resolvedHera;
+    }
+    let mod;
+    try {
+      mod = heraRequire("@danielx/hera");
+    } catch {
+      throw new Error("@danielx/hera is not installed; install it as a (peer) dependency to type-check .hera files, or pass HeraPluginOptions.Hera explicitly.");
+    }
+    resolvedHera = { compile: mod.compile };
+    return resolvedHera;
+  }
+  function getHeraVersion() {
+    if (resolvedHeraVersion) {
+      return resolvedHeraVersion;
+    }
+    if (options.HeraVersion) {
+      resolvedHeraVersion = options.HeraVersion;
+      return resolvedHeraVersion;
+    }
+    try {
+      const pkg = heraRequire("@danielx/hera/package.json");
+      resolvedHeraVersion = pkg.version;
+    } catch {
+      resolvedHeraVersion = "unknown";
+    }
+    return resolvedHeraVersion;
+  }
+  const heraOptions = {
+    module: true,
+    sourceMap: true,
+    language: "civet"
+  };
+  function transpileHera(p, source) {
+    const errors = [];
+    let ref;
+    if (cache) {
+      ref = makeCacheKey({
+        source,
+        sourcePath: p,
+        compilerName: "hera",
+        compilerVersion: getHeraVersion(),
+        civetVersion: CivetVersion,
+        options: { heraOptions, civetConfig }
+      });
+    } else ref = void 0;
+    const cacheKey = ref;
+    if (cacheKey) {
+      const hit = cache.get(cacheKey);
+      if (hit) {
+        try {
+          const { code, lines } = JSON.parse(hit);
+          return {
+            code,
+            sourceMap: { lines },
+            errors
+          };
+        } catch {
+        }
+      }
+    }
+    try {
+      const heraResult = getHera().compile(source, { ...heraOptions, filename: p });
+      const civetOptions = {
+        ...civetConfig,
+        filename: p,
+        js: false,
+        sync: true,
+        sourceMap: true,
+        upstreamSourceMap: heraResult.sourceMap,
+        parseOptions: {
+          ...civetConfig.parseOptions,
+          comptime: false
+        }
+      };
+      const civetResult = Civet.compile(heraResult.code, civetOptions);
+      if (cacheKey) {
+        const sm = civetResult.sourceMap;
+        const lines = sm?.lines ?? sm?.data?.lines;
+        cache.set(cacheKey, JSON.stringify({ code: civetResult.code, lines }));
+      }
+      return {
+        code: civetResult.code,
+        sourceMap: civetResult.sourceMap,
+        errors
+      };
+    } catch (e) {
+      errors.push(e);
+      return { code: "", errors };
+    }
+  }
+  return {
+    transpilers: [{
+      extension: ".hera",
+      target: ".tsx",
+      compile: transpileHera
+    }]
+  };
+}
+
+// source/ts-service/typecheck.civet
+import ts7 from "typescript";
+import * as fs2 from "fs";
+import * as path6 from "path";
+function makeIncrementalTypecheckProgram(projectPath, options) {
+  const transpilers = buildTranspilers(options.plugins);
+  const extraExtensions = Array.from(transpilers.keys());
+  const parsed = parseTsConfigForCivet(projectPath, transpilers, { tsConfig: options.tsConfig });
+  const compilerOptions = {
+    ...parsed.options,
+    ...options.extraCompilerOptions
+  };
+  compilerOptions.jsx ??= ts7.JsxEmit.Preserve;
+  const baseHost = ts7.createIncrementalCompilerHost(compilerOptions);
+  const fileMetaData = /* @__PURE__ */ new Map();
+  const hashText = (text) => {
+    return baseHost.createHash?.(text) ?? text.length.toString();
+  };
+  const origGetSourceFile = baseHost.getSourceFile.bind(baseHost);
+  baseHost.getSourceFile = (fileName, langVersion, onError, shouldCreateNew) => {
+    const exts = getTranspiledExtensionsFromPath(fileName);
+    const transpiler = exts && transpilers.get(exts[0]);
+    if (exts && transpiler && transpiler.target === exts[1]) {
+      const sourcePath = removeExtension(fileName);
+      let sourceText;
+      try {
+        sourceText = fs2.readFileSync(sourcePath, "utf8");
+      } catch {
+        return void 0;
+      }
+      let result;
+      try {
+        result = transpiler.compile(sourcePath, sourceText);
+      } catch (e) {
+        fileMetaData.set(getCanonicalFileName(sourcePath), {
+          sourcemapLines: void 0,
+          transpiledDoc: void 0,
+          commentRanges: void 0,
+          parseErrors: [e],
+          fatal: true
+        });
+        return void 0;
+      }
+      if (result instanceof Promise) {
+        return void 0;
+      }
+      if (!(result && result.code)) {
+        return void 0;
+      }
+      const sourcemapLines = result.sourceMap?.lines ?? result.sourceMap?.data?.lines;
+      fileMetaData.set(getCanonicalFileName(sourcePath), {
+        sourcemapLines,
+        transpiledDoc: void 0,
+        commentRanges: result.commentRanges,
+        parseErrors: result.errors,
+        fatal: false
+      });
+      const sf2 = ts7.createSourceFile(fileName, result.code, langVersion, true);
+      sf2.version = hashText(result.code);
+      return sf2;
+    }
+    const sf = origGetSourceFile(fileName, langVersion, onError, shouldCreateNew);
+    if (sf && sf.version === void 0) {
+      sf.version = hashText(sf.text);
+    }
+    return sf;
+  };
+  const origFileExists = baseHost.fileExists.bind(baseHost);
+  baseHost.fileExists = (fileName) => {
+    const exts = getTranspiledExtensionsFromPath(fileName);
+    if (exts) {
+      const transpiler = transpilers.get(exts[0]);
+      if (transpiler && transpiler.target === exts[1]) {
+        return origFileExists(removeExtension(fileName));
+      }
+    }
+    return origFileExists(fileName);
+  };
+  const origReadFile = baseHost.readFile.bind(baseHost);
+  baseHost.readFile = (fileName) => {
+    const contents = origReadFile(fileName);
+    if (contents && path6.basename(fileName) === "package.json") {
+      return mogrifyPackageJsonImports(contents, transpilers);
+    }
+    return contents;
+  };
+  baseHost.resolveModuleNameLiterals = (literals, containingFile, _redirected, opts) => {
+    return literals.map((lit) => {
+      const name = lit.text;
+      for (const ext of extraExtensions) {
+        if (name.endsWith(ext)) {
+          const t = transpilers.get(ext);
+          const containingDir = path6.dirname(containingFile);
+          const resolved = path6.resolve(containingDir, name);
+          if (origFileExists(resolved)) {
+            return {
+              resolvedModule: {
+                resolvedFileName: resolved + t.target,
+                extension: t.target,
+                isExternalLibraryImport: false
+              }
+            };
+          }
+        }
+      }
+      return { resolvedModule: ts7.resolveModuleName(name, containingFile, opts, baseHost).resolvedModule };
+    });
+  };
+  const programOptions = {
+    rootNames: parsed.fileNames,
+    options: compilerOptions,
+    host: baseHost,
+    configFileParsingDiagnostics: ts7.getConfigFileParsingDiagnostics(parsed)
+  };
+  if (parsed.projectReferences) {
+    programOptions.projectReferences = parsed.projectReferences;
+  }
+  const builder = ts7.createIncrementalProgram(programOptions);
+  return {
+    builder,
+    host: baseHost,
+    getMeta(sourcePath) {
+      return fileMetaData.get(getCanonicalFileName(sourcePath));
+    },
+    configErrors: parsed.errors
+  };
+}
+export {
+  Snap,
+  TSHost,
+  TSService,
+  createDiskCache,
+  createInMemoryDocFactory,
+  createMemoryCache,
+  fullDiffTextChangeRange,
+  getCanonicalFileName,
+  getExtensionFromPath,
+  getTranspiledExtensionsFromPath,
+  makeCivetPlugin,
+  makeHeraPlugin,
+  makeIncrementalTypecheckProgram,
+  remapFileName,
+  removeExtension
+};
+//# sourceMappingURL=index.mjs.map