@loopdive/js2 0.57.0

package/dist/index.js

@@ -0,0 +1,755 @@
+import * as path from "path";
+import { i as isKnownLibName, g as getLibSourceFile, a as getDefaultEnvironment, r as rewriteCjsRequire, f as forEachChild, c as compileSource, b as buildImports, d as compileFilesSource, e as compileMultiSource, h as compileToObjectSource } from "./runtime-C-4q_KwU.js";
+import { j, k, l, m, n, o, p, q, s } from "./runtime-C-4q_KwU.js";
+import ts from "typescript";
+class IncrementalLanguageService {
+  currentSource = "";
+  currentSourceFile;
+  fileName;
+  compilerOptions;
+  host;
+  // #2528/#2736 — the default-lib composite name for the current `analyze` call.
+  // `lib.d.ts` (DOM) by default; `lib.no-dom.d.ts` under `--target node`/`deno`.
+  // Read by the host's `getDefaultLibFileName` closure at `createProgram` time.
+  defaultLibName = "lib.d.ts";
+  constructor(fileName = "input.ts") {
+    this.fileName = fileName;
+    this.compilerOptions = {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      strict: true,
+      noImplicitAny: false,
+      noEmit: true
+    };
+    this.host = {
+      getSourceFile: (name, languageVersion) => {
+        if (name === this.fileName) return this.currentSourceFile;
+        return getLibSourceFile(name, languageVersion);
+      },
+      getDefaultLibFileName: () => this.defaultLibName,
+      writeFile: () => {
+      },
+      getCurrentDirectory: () => "/",
+      getCanonicalFileName: (f) => f,
+      useCaseSensitiveFileNames: () => true,
+      getNewLine: () => "\n",
+      fileExists: (name) => name === this.fileName || isKnownLibName(name),
+      readFile: (name) => {
+        if (name === this.fileName) return this.currentSource;
+        return void 0;
+      },
+      getDirectories: () => [],
+      directoryExists: () => true
+    };
+  }
+  /**
+   * Update the source for the next compilation.
+   *
+   * #2752 — `forceTsGrammar` forces `ScriptKind.TS` for the parsed SourceFile
+   * even when `fileName` ends in `.js` (otherwise `ts.createSourceFile` infers
+   * `ScriptKind.JS` from the extension and the loose-JS grammar checker rejects
+   * an injected TS prelude with TS8009/8010/8017). Mirrors the
+   * `forceTsGrammar` override in the non-incremental `analyzeSource`.
+   */
+  updateSource(source, fileName, forceTsGrammar) {
+    this.currentSource = source;
+    if (fileName) this.fileName = fileName;
+    this.currentSourceFile = ts.createSourceFile(
+      this.fileName,
+      this.currentSource,
+      this.compilerOptions.target ?? ts.ScriptTarget.ES2022,
+      true,
+      forceTsGrammar ? ts.ScriptKind.TS : void 0
+    );
+  }
+  /**
+   * Analyze — fresh Program + fresh checker, cached lib SourceFiles.
+   */
+  analyze(analyzeOptions) {
+    const options = { ...this.compilerOptions };
+    if (analyzeOptions?.allowJs) {
+      options.allowJs = true;
+      options.checkJs = true;
+    }
+    this.defaultLibName = analyzeOptions?.platform === "node" || analyzeOptions?.platform === "deno" ? "lib.no-dom.d.ts" : "lib.d.ts";
+    const program = ts.createProgram([this.fileName], options, this.host);
+    const checker = program.getTypeChecker();
+    const syntacticDiagnostics = program.getSyntacticDiagnostics();
+    const semanticDiagnostics = analyzeOptions?.skipSemanticDiagnostics ? [] : program.getSemanticDiagnostics();
+    const diagnostics = [...syntacticDiagnostics, ...semanticDiagnostics];
+    return {
+      sourceFile: program.getSourceFile(this.fileName),
+      checker,
+      program,
+      diagnostics,
+      syntacticDiagnostics
+    };
+  }
+  dispose() {
+  }
+}
+function getFs() {
+  return getDefaultEnvironment().fs;
+}
+class ModuleResolver {
+  constructor(rootDir, options) {
+    this.rootDir = rootDir;
+    this.externals = new Set(options?.externals ?? []);
+    this.extensions = options?.resolve?.extensions ?? [".ts", ".tsx", ".d.ts"];
+    const moduleDirs = options?.resolve?.modules ?? ["node_modules"];
+    this.compilerOptions = {
+      target: ts.ScriptTarget.ES2022,
+      module: ts.ModuleKind.ESNext,
+      moduleResolution: ts.ModuleResolutionKind.Node10,
+      baseUrl: rootDir,
+      rootDir,
+      // Allow TS to find types in the specified module directories
+      typeRoots: moduleDirs.map((d) => path.isAbsolute(d) ? d : path.resolve(rootDir, d)),
+      // Try to load tsconfig.json paths if available
+      ...this.loadTsconfigPaths()
+    };
+    this.host = {
+      fileExists: (fileName) => {
+        try {
+          return getFs().statSync(fileName).isFile();
+        } catch {
+          return false;
+        }
+      },
+      readFile: (fileName) => {
+        try {
+          return getFs().readFileSync(fileName, "utf-8");
+        } catch {
+          return void 0;
+        }
+      },
+      directoryExists: (dirName) => {
+        try {
+          return getFs().statSync(dirName).isDirectory();
+        } catch {
+          return false;
+        }
+      },
+      getCurrentDirectory: () => rootDir,
+      getDirectories: (dirPath) => {
+        try {
+          return getFs().readdirSync(dirPath, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+        } catch {
+          return [];
+        }
+      },
+      realpath: (p2) => {
+        try {
+          return getFs().realpathSync(p2);
+        } catch {
+          return p2;
+        }
+      }
+    };
+  }
+  compilerOptions;
+  host;
+  externals;
+  extensions;
+  resolveCache = /* @__PURE__ */ new Map();
+  /**
+   * Try to load tsconfig.json paths configuration from the root directory.
+   */
+  loadTsconfigPaths() {
+    const tsconfigPath = path.join(this.rootDir, "tsconfig.json");
+    try {
+      if (!getFs().statSync(tsconfigPath).isFile()) return {};
+    } catch {
+      return {};
+    }
+    const configFile = ts.readConfigFile(tsconfigPath, (p2) => getFs().readFileSync(p2, "utf-8"));
+    if (configFile.error || !configFile.config) return {};
+    const parsed = ts.parseJsonConfigFileContent(configFile.config, ts.sys, this.rootDir);
+    const result = {};
+    if (parsed.options.paths) {
+      result.paths = parsed.options.paths;
+    }
+    if (parsed.options.baseUrl) {
+      result.baseUrl = parsed.options.baseUrl;
+    }
+    return result;
+  }
+  /**
+   * Resolve a module specifier to a file path.
+   *
+   * @param specifier - The import specifier (e.g., "lodash", "./utils")
+   * @param containingFile - The file that contains the import statement
+   * @returns The resolved file path, or null if the module is external or not found
+   */
+  resolve(specifier, containingFile) {
+    const pkgName = getBarePackageName(specifier);
+    if (pkgName && this.externals.has(pkgName)) {
+      return null;
+    }
+    const cacheKey = `${containingFile}::${specifier}`;
+    if (this.resolveCache.has(cacheKey)) {
+      return this.resolveCache.get(cacheKey);
+    }
+    const result = ts.resolveModuleName(specifier, containingFile, this.compilerOptions, this.host);
+    let resolved = null;
+    if (result.resolvedModule) {
+      resolved = result.resolvedModule.resolvedFileName;
+      resolved = path.resolve(resolved);
+      if (pkgName && (/[/\\]@types[/\\]/.test(resolved) || resolved.endsWith(".d.ts"))) {
+        const implPath = this.findImplementationBody(pkgName, specifier, containingFile);
+        if (implPath) {
+          resolved = implPath;
+        }
+      }
+    }
+    this.resolveCache.set(cacheKey, resolved);
+    return resolved;
+  }
+  /**
+   * When `ts.resolveModuleName` returned a file under `@types/<pkg>/`,
+   * attempt to find the matching real implementation body in a sibling
+   * `node_modules/<pkg>/` directory and return its absolute path, or null
+   * if no implementation file can be located.
+   *
+   * Handles both standard npm layouts (`node_modules/<pkg>/...`) and pnpm
+   * layouts (where `@types/<pkg>` lives under `.pnpm/` but the real package
+   * is still hoisted to the top-level `node_modules/<pkg>`). The search
+   * walks up from `containingFile` through parent directories looking for
+   * each candidate — this matches Node's own module resolution walk.
+   */
+  findImplementationBody(pkgName, specifier, containingFile) {
+    const fs = getFs();
+    if (!fs) return null;
+    const afterPkg = specifier.slice(pkgName.length).replace(/^\//, "");
+    const probeExtensions = ["", ".js", ".mjs", ".cjs", ".ts"];
+    let dir = path.dirname(containingFile);
+    const root = path.parse(dir).root;
+    const seenDirs = /* @__PURE__ */ new Set();
+    while (!seenDirs.has(dir)) {
+      seenDirs.add(dir);
+      const pkgRoot = path.join(dir, "node_modules", pkgName);
+      if (this.tryStatDir(pkgRoot)) {
+        const found = this.probeImplementationPath(pkgRoot, afterPkg, probeExtensions);
+        if (found) return found;
+      }
+      if (dir === root) break;
+      const parent = path.dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    const rootPkg = path.join(this.rootDir, "node_modules", pkgName);
+    if (this.tryStatDir(rootPkg)) {
+      const found = this.probeImplementationPath(rootPkg, afterPkg, probeExtensions);
+      if (found) return found;
+    }
+    return null;
+  }
+  tryStatDir(p2) {
+    const fs = getFs();
+    if (!fs) return false;
+    try {
+      return fs.statSync(p2).isDirectory();
+    } catch {
+      return false;
+    }
+  }
+  tryStatFile(p2) {
+    const fs = getFs();
+    if (!fs) return false;
+    try {
+      return fs.statSync(p2).isFile();
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Given a package root (e.g. `.../node_modules/lodash-es`) and a subpath
+   * from a specifier (e.g. `identity.js` or `identity` or ``), attempt to
+   * locate the implementation file on disk using the probe extensions.
+   */
+  probeImplementationPath(pkgRoot, afterPkg, exts) {
+    if (afterPkg === "") {
+      const pkgJsonPath = path.join(pkgRoot, "package.json");
+      if (this.tryStatFile(pkgJsonPath)) {
+        try {
+          const pkg = JSON.parse(getFs().readFileSync(pkgJsonPath, "utf-8"));
+          const mainField = pkg.module ?? pkg.main;
+          if (typeof mainField === "string" && mainField.length > 0) {
+            const mainPath = path.resolve(pkgRoot, mainField);
+            if (this.tryStatFile(mainPath)) return mainPath;
+            for (const ext of exts) {
+              if (ext === "") continue;
+              const withExt = mainPath + ext;
+              if (this.tryStatFile(withExt)) return withExt;
+            }
+          }
+        } catch {
+        }
+      }
+      for (const ext of exts) {
+        if (ext === "") continue;
+        const indexPath = path.join(pkgRoot, "index" + ext);
+        if (this.tryStatFile(indexPath)) return indexPath;
+      }
+      return null;
+    }
+    const direct = path.join(pkgRoot, afterPkg);
+    if (this.tryStatFile(direct)) return direct;
+    if (afterPkg.endsWith(".js")) {
+      const asTs = path.join(pkgRoot, afterPkg.slice(0, -3) + ".ts");
+      if (this.tryStatFile(asTs)) return asTs;
+      const asMjs = path.join(pkgRoot, afterPkg.slice(0, -3) + ".mjs");
+      if (this.tryStatFile(asMjs)) return asMjs;
+    }
+    if (!/\.[a-zA-Z0-9]+$/.test(afterPkg)) {
+      for (const ext of exts) {
+        if (ext === "") continue;
+        const withExt = path.join(pkgRoot, afterPkg + ext);
+        if (this.tryStatFile(withExt)) return withExt;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if a specifier refers to an external package.
+   */
+  isExternal(specifier) {
+    const pkgName = getBarePackageName(specifier);
+    return pkgName !== null && this.externals.has(pkgName);
+  }
+}
+function getBarePackageName(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) {
+    return null;
+  }
+  if (specifier.startsWith("@")) {
+    const parts = specifier.split("/");
+    if (parts.length >= 2) {
+      return `${parts[0]}/${parts[1]}`;
+    }
+    return specifier;
+  }
+  const slashIdx = specifier.indexOf("/");
+  if (slashIdx === -1) return specifier;
+  return specifier.slice(0, slashIdx);
+}
+function resolveAllImports(entryFile, resolver) {
+  const resolved = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const onStack = /* @__PURE__ */ new Set();
+  function visit(filePath) {
+    if (visited.has(filePath) || onStack.has(filePath)) return;
+    onStack.add(filePath);
+    let content;
+    try {
+      content = getFs().readFileSync(filePath, "utf-8");
+    } catch {
+      onStack.delete(filePath);
+      return;
+    }
+    content = rewriteCjsRequire(content);
+    const sf = ts.createSourceFile(
+      filePath,
+      content,
+      ts.ScriptTarget.Latest,
+      true,
+      filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+    );
+    for (const stmt of sf.statements) {
+      if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier)) {
+        const specifier = stmt.moduleSpecifier.text;
+        const resolvedPath = resolver.resolve(specifier, filePath);
+        if (resolvedPath) visit(resolvedPath);
+      }
+      if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier && ts.isStringLiteral(stmt.moduleSpecifier)) {
+        const specifier = stmt.moduleSpecifier.text;
+        const resolvedPath = resolver.resolve(specifier, filePath);
+        if (resolvedPath) visit(resolvedPath);
+      }
+    }
+    visited.add(filePath);
+    onStack.delete(filePath);
+    resolved.set(filePath, content);
+  }
+  visit(path.resolve(entryFile));
+  return resolved;
+}
+function treeshake(entryExports, sourceFiles, checker) {
+  const reachable = /* @__PURE__ */ new Set();
+  const visitedSymbols = /* @__PURE__ */ new Set();
+  const symbolToDecl = /* @__PURE__ */ new Map();
+  for (const sf of sourceFiles) {
+    for (const stmt of sf.statements) {
+      const symbols = getTopLevelSymbols(stmt, checker);
+      for (const sym of symbols) {
+        symbolToDecl.set(sym, stmt);
+      }
+    }
+  }
+  const entryFile = sourceFiles[sourceFiles.length - 1];
+  if (!entryFile) return reachable;
+  const entryExportSet = new Set(entryExports);
+  for (const stmt of entryFile.statements) {
+    if (!hasExportModifier(stmt)) continue;
+    const names = getDeclaredNames(stmt);
+    for (const name of names) {
+      if (entryExportSet.size === 0 || entryExportSet.has(name)) {
+        const symbols = getTopLevelSymbols(stmt, checker);
+        for (const sym of symbols) {
+          markReachable(sym, symbolToDecl, reachable, visitedSymbols, checker);
+        }
+      }
+    }
+  }
+  for (const sf of sourceFiles) {
+    for (const stmt of sf.statements) {
+      if (isSideEffectStatement(stmt)) {
+        reachable.add(stmt);
+        const symbols = getTopLevelSymbols(stmt, checker);
+        for (const sym of symbols) {
+          markReachable(sym, symbolToDecl, reachable, visitedSymbols, checker);
+        }
+      }
+    }
+  }
+  return reachable;
+}
+function markReachable(sym, symbolToDecl, reachable, visitedSymbols, checker) {
+  if (visitedSymbols.has(sym)) return;
+  visitedSymbols.add(sym);
+  const aliased = getAliasedSymbol(sym, checker);
+  if (aliased && aliased !== sym) {
+    markReachable(aliased, symbolToDecl, reachable, visitedSymbols, checker);
+  }
+  const declNode = symbolToDecl.get(sym);
+  if (declNode) {
+    reachable.add(declNode);
+  }
+  if (aliased && aliased !== sym) {
+    const aliasedDecl = symbolToDecl.get(aliased);
+    if (aliasedDecl) {
+      reachable.add(aliasedDecl);
+    }
+  }
+  const declarations = sym.getDeclarations() ?? [];
+  for (const decl of declarations) {
+    walkReferences(decl, symbolToDecl, reachable, visitedSymbols, checker);
+  }
+}
+function walkReferences(node, symbolToDecl, reachable, visitedSymbols, checker) {
+  function visit(n2) {
+    if (ts.isIdentifier(n2)) {
+      try {
+        const sym = checker.getSymbolAtLocation(n2);
+        if (sym) {
+          markReachable(sym, symbolToDecl, reachable, visitedSymbols, checker);
+        }
+      } catch {
+      }
+    }
+    if (ts.isTypeReferenceNode(n2)) {
+      try {
+        const sym = checker.getSymbolAtLocation(n2.typeName);
+        if (sym) {
+          markReachable(sym, symbolToDecl, reachable, visitedSymbols, checker);
+        }
+      } catch {
+      }
+    }
+    forEachChild(n2, visit);
+  }
+  visit(node);
+}
+function getAliasedSymbol(sym, checker) {
+  try {
+    if (sym.flags & ts.SymbolFlags.Alias) {
+      return checker.getAliasedSymbol(sym);
+    }
+  } catch {
+  }
+  return void 0;
+}
+function getTopLevelSymbols(stmt, checker) {
+  const symbols = [];
+  if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+    const sym = checker.getSymbolAtLocation(stmt.name);
+    if (sym) symbols.push(sym);
+  } else if (ts.isClassDeclaration(stmt) && stmt.name) {
+    const sym = checker.getSymbolAtLocation(stmt.name);
+    if (sym) symbols.push(sym);
+  } else if (ts.isVariableStatement(stmt)) {
+    for (const decl of stmt.declarationList.declarations) {
+      if (ts.isIdentifier(decl.name)) {
+        const sym = checker.getSymbolAtLocation(decl.name);
+        if (sym) symbols.push(sym);
+      }
+    }
+  } else if (ts.isEnumDeclaration(stmt)) {
+    const sym = checker.getSymbolAtLocation(stmt.name);
+    if (sym) symbols.push(sym);
+  } else if (ts.isInterfaceDeclaration(stmt)) {
+    const sym = checker.getSymbolAtLocation(stmt.name);
+    if (sym) symbols.push(sym);
+  } else if (ts.isTypeAliasDeclaration(stmt)) {
+    const sym = checker.getSymbolAtLocation(stmt.name);
+    if (sym) symbols.push(sym);
+  }
+  return symbols;
+}
+function getDeclaredNames(stmt) {
+  const names = [];
+  if (ts.isFunctionDeclaration(stmt) && stmt.name) {
+    names.push(stmt.name.text);
+  } else if (ts.isClassDeclaration(stmt) && stmt.name) {
+    names.push(stmt.name.text);
+  } else if (ts.isVariableStatement(stmt)) {
+    for (const decl of stmt.declarationList.declarations) {
+      if (ts.isIdentifier(decl.name)) {
+        names.push(decl.name.text);
+      }
+    }
+  } else if (ts.isEnumDeclaration(stmt)) {
+    names.push(stmt.name.text);
+  } else if (ts.isInterfaceDeclaration(stmt)) {
+    names.push(stmt.name.text);
+  } else if (ts.isTypeAliasDeclaration(stmt)) {
+    names.push(stmt.name.text);
+  }
+  return names;
+}
+function hasExportModifier(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return modifiers?.some((m2) => m2.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function isSideEffectStatement(stmt) {
+  if (ts.isImportDeclaration(stmt)) return true;
+  if (ts.isExportDeclaration(stmt) && stmt.moduleSpecifier) return true;
+  if (ts.isExpressionStatement(stmt)) return true;
+  return false;
+}
+function getEntryExportNames(entryFile) {
+  const names = [];
+  for (const stmt of entryFile.statements) {
+    if (hasExportModifier(stmt)) {
+      names.push(...getDeclaredNames(stmt));
+    }
+  }
+  return names;
+}
+const RUNTIME_RECGROUP_TYPE_NAMES = [
+  // String family (i16-array native-string backend).
+  "AnyString",
+  "NativeString",
+  "ConsString",
+  "__str_data",
+  // Vec / array family (name-stable members only).
+  "__vec_base",
+  "__vec_f64",
+  "__arr_f64"
+];
+const RUNTIME_RECGROUP_ABI_VERSION = 1;
+const RUNTIME_NAME_SET = new Set(RUNTIME_RECGROUP_TYPE_NAMES);
+function typeDefName(t) {
+  switch (t.kind) {
+    case "func":
+    case "struct":
+    case "array":
+      return t.name;
+    case "sub":
+      return t.name;
+    case "rec":
+      return void 0;
+  }
+}
+function valTypeToken(t, localOf) {
+  switch (t.kind) {
+    case "ref":
+    case "ref_null": {
+      const local = localOf(t.typeIdx);
+      const nul = t.kind === "ref_null" ? "n" : "";
+      if (local !== void 0) return `${nul}r${local}`;
+      return `${nul}x`;
+    }
+    case "i32":
+      return t.boolean ? "i32b" : "i32";
+    case "i64":
+      return t.bigint ? "i64big" : "i64";
+    default:
+      return t.kind;
+  }
+}
+function fieldToken(f, localOf) {
+  return `${f.mutable ? "m" : ""}${valTypeToken(f.type, localOf)}`;
+}
+function structuralToken(t, localOf) {
+  switch (t.kind) {
+    case "func": {
+      const p2 = t.params.map((v) => valTypeToken(v, localOf)).join(",");
+      const r = t.results.map((v) => valTypeToken(v, localOf)).join(",");
+      return `func(${p2})->(${r})`;
+    }
+    case "struct": {
+      const sup = t.superTypeIdx !== void 0 && t.superTypeIdx >= 0 ? (() => {
+        const local = localOf(t.superTypeIdx);
+        return local !== void 0 ? `sub r${local}${t.final ? "!" : ""} ` : `sub x${t.final ? "!" : ""} `;
+      })() : "";
+      const fields = t.fields.map((f) => fieldToken(f, localOf)).join(";");
+      return `${sup}struct{${fields}}`;
+    }
+    case "array":
+      return `array<${t.mutable ? "m" : ""}${valTypeToken(t.element, localOf)}>`;
+    case "sub": {
+      const sup = t.superType !== null ? (() => {
+        const local = localOf(t.superType);
+        return local !== void 0 ? `sub r${local}${t.final ? "!" : ""} ` : `sub x${t.final ? "!" : ""} `;
+      })() : t.final ? "final " : "";
+      return `${sup}${structuralToken(t.type, localOf)}`;
+    }
+  }
+}
+function fnv1a64(s2) {
+  let h = 0xcbf29ce484222325n;
+  const prime = 0x100000001b3n;
+  const mask = 0xffffffffffffffffn;
+  for (let i = 0; i < s2.length; i++) {
+    h ^= BigInt(s2.charCodeAt(i));
+    h = h * prime & mask;
+  }
+  return h.toString(16).padStart(16, "0");
+}
+function canonicalHashOfTypeGroup(group, absIndices) {
+  const indexToLocal = /* @__PURE__ */ new Map();
+  for (let i = 0; i < absIndices.length; i++) indexToLocal.set(absIndices[i], i);
+  const localOf = (absIdx) => indexToLocal.get(absIdx);
+  const parts = [`v${RUNTIME_RECGROUP_ABI_VERSION}`, `n${group.length}`];
+  for (let i = 0; i < group.length; i++) {
+    parts.push(`${i}:${structuralToken(group[i], localOf)}`);
+  }
+  return fnv1a64(parts.join("|"));
+}
+function extractRuntimeGroup(mod) {
+  const out = [];
+  const types = mod.types;
+  for (let i = 0; i < types.length; i++) {
+    const t = types[i];
+    if (t.kind === "rec") continue;
+    const name = typeDefName(t);
+    if (name !== void 0 && RUNTIME_NAME_SET.has(name)) {
+      out.push({ name, absIndex: i, def: t });
+    }
+  }
+  return out;
+}
+function fingerprintRuntimeGroup(mod) {
+  const members = extractRuntimeGroup(mod);
+  return {
+    abiVersion: RUNTIME_RECGROUP_ABI_VERSION,
+    hash: canonicalHashOfTypeGroup(
+      members.map((m2) => m2.def),
+      members.map((m2) => m2.absIndex)
+    ),
+    members: members.map((m2) => m2.name),
+    count: members.length
+  };
+}
+async function compile(source, options) {
+  return withImportObject(await compileSource(source, options));
+}
+function withImportObject(result) {
+  let cached;
+  Object.defineProperty(result, "importObject", {
+    enumerable: true,
+    configurable: true,
+    get() {
+      if (cached) return cached;
+      if (!result.success || result.imports.length === 0) {
+        cached = {};
+        return cached;
+      }
+      const built = buildImports(result.imports, void 0, result.stringPool);
+      cached = {
+        env: built.env,
+        "wasm:js-string": built["wasm:js-string"],
+        string_constants: built.string_constants
+      };
+      if (built.setExports) {
+        Object.defineProperty(cached, "__setExports", {
+          value: built.setExports,
+          enumerable: false,
+          configurable: true
+        });
+      }
+      return cached;
+    }
+  });
+  return result;
+}
+async function compileMulti(files, entryFile, options) {
+  return withImportObject(await compileMultiSource(files, entryFile, options));
+}
+async function compileFiles(entryPath, options) {
+  return withImportObject(await compileFilesSource(entryPath, options));
+}
+async function compileToWat(source) {
+  const result = await compileSource(source, { emitWat: true });
+  return result.wat;
+}
+function compileToObject(source, options) {
+  return compileToObjectSource(source, options);
+}
+async function compileProject(entryFile, options) {
+  const resolvedEntry = path.resolve(entryFile);
+  const rootDir = path.dirname(resolvedEntry);
+  const isJs = /\.[cm]?js$/.test(resolvedEntry);
+  const effectiveOptions = isJs && !options?.allowJs ? { ...options, allowJs: true } : options;
+  const resolver = new ModuleResolver(rootDir, effectiveOptions);
+  const allFiles = resolveAllImports(resolvedEntry, resolver);
+  const files = {};
+  for (const [filePath, content] of allFiles) {
+    const relPath = path.relative(rootDir, filePath);
+    const key = relPath.startsWith(".") ? relPath : `./${relPath}`;
+    files[key] = content;
+  }
+  const entryKey = `./${path.relative(rootDir, resolvedEntry)}`;
+  return withImportObject(await compileMultiSource(files, entryKey, effectiveOptions));
+}
+function createIncrementalCompiler(defaultOptions) {
+  const service = new IncrementalLanguageService();
+  return {
+    compile(source, options) {
+      return compileSource(source, { ...defaultOptions, ...options }, service);
+    },
+    dispose() {
+      service.dispose();
+    }
+  };
+}
+export {
+  ModuleResolver,
+  RUNTIME_RECGROUP_ABI_VERSION,
+  RUNTIME_RECGROUP_TYPE_NAMES,
+  buildImports,
+  j as buildStringConstants,
+  k as buildWasiPolyfill,
+  canonicalHashOfTypeGroup,
+  l as checkPolicy,
+  compile,
+  m as compileAndInstantiate,
+  compileFiles,
+  compileMulti,
+  compileProject,
+  compileToObject,
+  compileToWat,
+  createIncrementalCompiler,
+  extractRuntimeGroup,
+  fingerprintRuntimeGroup,
+  n as generateWit,
+  getBarePackageName,
+  getEntryExportNames,
+  o as instantiateWasm,
+  p as instantiateWasmStreaming,
+  q as jsString,
+  s as preloadLibFiles,
+  resolveAllImports,
+  treeshake
+};