durable-actors 0.7.15 → 0.8.0

package/dist/compiler/declarations.js

@@ -1,218 +1,2683 @@
-import { generateDtsBundle } from "dts-bundle-generator";
+/*! dts-bundle-generator
+MIT License
+
+Copyright (c) 2017 Evgeniy Timokhov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+import { createRequire } from "node:module"; const require = createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/logger.js
+var require_logger = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/logger.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.enableNormalLog = exports.enableVerbose = exports.errorLog = exports.warnLog = exports.normalLog = exports.verboseLog = void 0;
+    function verboseLog(message) {
+      logMessage(
+        message,
+        0
+        /* LogLevel.Verbose */
+      );
+    }
+    exports.verboseLog = verboseLog;
+    function normalLog(message) {
+      logMessage(
+        message,
+        1
+        /* LogLevel.Normal */
+      );
+    }
+    exports.normalLog = normalLog;
+    function warnLog(message) {
+      logMessage(
+        message,
+        2
+        /* LogLevel.Warning */
+      );
+    }
+    exports.warnLog = warnLog;
+    function errorLog(message) {
+      logMessage(
+        message,
+        3
+        /* LogLevel.Error */
+      );
+    }
+    exports.errorLog = errorLog;
+    var currentLogLevel = 3;
+    function enableVerbose() {
+      currentLogLevel = 0;
+      normalLog("Verbose log enabled");
+    }
+    exports.enableVerbose = enableVerbose;
+    function enableNormalLog() {
+      currentLogLevel = 1;
+    }
+    exports.enableNormalLog = enableNormalLog;
+    function logMessage(message, level = 0) {
+      if (level < currentLogLevel) {
+        return;
+      }
+      switch (level) {
+        case 3:
+          console.error(`\x1B[0;31m${message}\x1B[0m`);
+          break;
+        case 2:
+          console.warn(`\x1B[1;33m${message}\x1B[0m`);
+          break;
+        case 1:
+        case 0:
+          console.log(message);
+      }
+    }
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/fix-path.js
+var require_fix_path = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/fix-path.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.fixPath = void 0;
+    function fixPath(path2) {
+      return path2.replace(/\\/g, "/");
+    }
+    exports.fixPath = fixPath;
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/get-absolute-path.js
+var require_get_absolute_path = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/get-absolute-path.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getAbsolutePath = void 0;
+    var path2 = __require("path");
+    var process = __require("process");
+    var fix_path_1 = require_fix_path();
+    function getAbsolutePath(fileName, cwd) {
+      if (!path2.isAbsolute(fileName)) {
+        fileName = path2.join(cwd !== void 0 ? cwd : process.cwd(), fileName);
+      }
+      return (0, fix_path_1.fixPath)(fileName);
+    }
+    exports.getAbsolutePath = getAbsolutePath;
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/check-diagnostics-errors.js
+var require_check_diagnostics_errors = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/check-diagnostics-errors.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.checkDiagnosticsErrors = exports.checkProgramDiagnosticsErrors = void 0;
+    var ts2 = __require("typescript");
+    var logger_1 = require_logger();
+    var formatDiagnosticsHost = {
+      getCanonicalFileName: (fileName) => ts2.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
+      getCurrentDirectory: ts2.sys.getCurrentDirectory,
+      getNewLine: () => ts2.sys.newLine
+    };
+    function checkProgramDiagnosticsErrors(program) {
+      if (!program.getCompilerOptions().declaration) {
+        throw new Error(`Something went wrong - the program doesn't have declaration option enabled`);
+      }
+      checkDiagnosticsErrors(ts2.getPreEmitDiagnostics(program), "Compiled with errors");
+    }
+    exports.checkProgramDiagnosticsErrors = checkProgramDiagnosticsErrors;
+    function checkDiagnosticsErrors(diagnostics, failMessage) {
+      if (diagnostics.length === 0) {
+        return;
+      }
+      (0, logger_1.errorLog)(ts2.formatDiagnostics(diagnostics, formatDiagnosticsHost).trim());
+      throw new Error(failMessage);
+    }
+    exports.checkDiagnosticsErrors = checkDiagnosticsErrors;
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/get-compiler-options.js
+var require_get_compiler_options = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/get-compiler-options.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getCompilerOptions = void 0;
+    var ts2 = __require("typescript");
+    var path2 = __require("path");
+    var get_absolute_path_1 = require_get_absolute_path();
+    var check_diagnostics_errors_1 = require_check_diagnostics_errors();
+    var logger_1 = require_logger();
+    var parseConfigHost = {
+      useCaseSensitiveFileNames: ts2.sys.useCaseSensitiveFileNames,
+      readDirectory: ts2.sys.readDirectory,
+      fileExists: ts2.sys.fileExists,
+      readFile: ts2.sys.readFile
+    };
+    function getCompilerOptions(inputFileNames, preferredConfigPath) {
+      const configFileName = preferredConfigPath !== void 0 ? preferredConfigPath : findConfig(inputFileNames);
+      (0, logger_1.verboseLog)(`Using config: ${configFileName}`);
+      const configParseResult = ts2.readConfigFile(configFileName, ts2.sys.readFile);
+      (0, check_diagnostics_errors_1.checkDiagnosticsErrors)(configParseResult.error !== void 0 ? [configParseResult.error] : [], "Error while processing tsconfig file");
+      const compilerOptionsParseResult = ts2.parseJsonConfigFileContent(configParseResult.config, parseConfigHost, path2.resolve(path2.dirname(configFileName)), void 0, (0, get_absolute_path_1.getAbsolutePath)(configFileName));
+      const diagnostics = compilerOptionsParseResult.errors.filter(
+        (d) => d.code !== 18003
+        /* Constants.NoInputsWereFoundDiagnosticCode */
+      );
+      (0, check_diagnostics_errors_1.checkDiagnosticsErrors)(diagnostics, "Error while processing tsconfig compiler options");
+      return compilerOptionsParseResult.options;
+    }
+    exports.getCompilerOptions = getCompilerOptions;
+    function findConfig(inputFiles) {
+      if (inputFiles.length !== 1) {
+        throw new Error("Cannot find tsconfig for multiple files. Please specify preferred tsconfig file");
+      }
+      const searchPath = (0, get_absolute_path_1.getAbsolutePath)(inputFiles[0]);
+      const configFileName = ts2.findConfigFile(searchPath, ts2.sys.fileExists);
+      if (!configFileName) {
+        throw new Error(`Cannot find config file for file ${searchPath}`);
+      }
+      return configFileName;
+    }
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/compile-dts.js
+var require_compile_dts = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/compile-dts.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.compileDts = void 0;
+    var ts2 = __require("typescript");
+    var logger_1 = require_logger();
+    var get_compiler_options_1 = require_get_compiler_options();
+    var check_diagnostics_errors_1 = require_check_diagnostics_errors();
+    var declarationExtsRemapping = {
+      [ts2.Extension.Js]: ts2.Extension.Js,
+      [ts2.Extension.Jsx]: ts2.Extension.Jsx,
+      [ts2.Extension.Json]: ts2.Extension.Json,
+      [ts2.Extension.TsBuildInfo]: ts2.Extension.TsBuildInfo,
+      [ts2.Extension.Mjs]: ts2.Extension.Mjs,
+      [ts2.Extension.Cjs]: ts2.Extension.Cjs,
+      [ts2.Extension.Ts]: ts2.Extension.Dts,
+      [ts2.Extension.Tsx]: ts2.Extension.Dts,
+      [ts2.Extension.Dts]: ts2.Extension.Dts,
+      [ts2.Extension.Mts]: ts2.Extension.Dmts,
+      [ts2.Extension.Dmts]: ts2.Extension.Dmts,
+      [ts2.Extension.Cts]: ts2.Extension.Dcts,
+      [ts2.Extension.Dcts]: ts2.Extension.Dcts
+    };
+    function compileDts(rootFiles, preferredConfigPath, followSymlinks = true) {
+      const compilerOptions = (0, get_compiler_options_1.getCompilerOptions)(rootFiles, preferredConfigPath);
+      compilerOptions.outDir = void 0;
+      compilerOptions.incremental = void 0;
+      compilerOptions.tsBuildInfoFile = void 0;
+      compilerOptions.declarationDir = void 0;
+      compilerOptions.declaration = true;
+      if (compilerOptions.composite) {
+        (0, logger_1.warnLog)(`Composite projects aren't supported at the time. Prefer to use non-composite project to generate declarations instead or just ignore this message if everything works fine. See https://github.com/timocov/dts-bundle-generator/issues/93`);
+        compilerOptions.composite = void 0;
+      }
+      const host = createCachingCompilerHost(compilerOptions);
+      const dtsFiles = getDeclarationFiles(rootFiles, compilerOptions, host);
+      if (!followSymlinks) {
+        host.realpath = (p) => p;
+      }
+      const moduleResolutionCache = ts2.createModuleResolutionCache(host.getCurrentDirectory(), host.getCanonicalFileName, compilerOptions);
+      host.resolveModuleNameLiterals = (moduleLiterals, containingFile) => {
+        return moduleLiterals.map((moduleLiteral) => {
+          const resolvedModule = ts2.resolveModuleName(moduleLiteral.text, containingFile, compilerOptions, host, moduleResolutionCache).resolvedModule;
+          if (resolvedModule && !resolvedModule.isExternalLibraryImport) {
+            const newExt = declarationExtsRemapping[resolvedModule.extension];
+            if (newExt === void 0) {
+              (0, logger_1.verboseLog)(`Skipping module ${resolvedModule.resolvedFileName} because it has unsupported extension "${resolvedModule.extension}"`);
+              return { resolvedModule };
+            }
+            if (newExt !== resolvedModule.extension) {
+              (0, logger_1.verboseLog)(`Changing module from ${resolvedModule.extension} to ${newExt} for ${resolvedModule.resolvedFileName}`);
+              resolvedModule.extension = newExt;
+              resolvedModule.resolvedFileName = changeExtensionToDts(resolvedModule.resolvedFileName);
+            }
+          }
+          return { resolvedModule };
+        });
+      };
+      const originalGetSourceFile = host.getSourceFile;
+      host.getSourceFile = (fileName, languageVersion, onError) => {
+        const storedValue = dtsFiles.get(host.getCanonicalFileName(fileName));
+        if (storedValue !== void 0) {
+          return ts2.createSourceFile(fileName, storedValue, languageVersion);
+        }
+        return originalGetSourceFile(fileName, languageVersion, onError);
+      };
+      const rootFilesRemapping = /* @__PURE__ */ new Map();
+      const inputFiles = rootFiles.map((rootFile) => {
+        const rootDtsFile = changeExtensionToDts(rootFile);
+        rootFilesRemapping.set(rootFile, rootDtsFile);
+        return rootDtsFile;
+      });
+      const program = ts2.createProgram(inputFiles, compilerOptions, host);
+      (0, check_diagnostics_errors_1.checkProgramDiagnosticsErrors)(program);
+      warnAboutTypeScriptFilesInProgram(program);
+      return { program, rootFilesRemapping };
+    }
+    exports.compileDts = compileDts;
+    function createCachingCompilerHost(compilerOptions) {
+      const host = ts2.createIncrementalCompilerHost(compilerOptions);
+      const sourceFilesCache = /* @__PURE__ */ new Map();
+      const originalGetSourceFile = host.getSourceFile;
+      host.getSourceFile = (fileName, languageVersion, onError) => {
+        const key = host.getCanonicalFileName(fileName);
+        let cacheValue = sourceFilesCache.get(key);
+        if (cacheValue === void 0) {
+          cacheValue = originalGetSourceFile(fileName, languageVersion, onError);
+          sourceFilesCache.set(key, cacheValue);
+        }
+        return cacheValue;
+      };
+      return host;
+    }
+    function changeExtensionToDts(fileName) {
+      let ext;
+      if (fileName.endsWith(ts2.Extension.Dts)) {
+        return fileName;
+      }
+      if (fileName.endsWith(ts2.Extension.Cts)) {
+        ext = ts2.Extension.Cts;
+      } else if (fileName.endsWith(ts2.Extension.Mts)) {
+        ext = ts2.Extension.Mts;
+      } else if (fileName.endsWith(ts2.Extension.Ts)) {
+        ext = ts2.Extension.Ts;
+      } else if (fileName.endsWith(ts2.Extension.Tsx)) {
+        ext = ts2.Extension.Tsx;
+      }
+      if (ext === void 0) {
+        return fileName;
+      }
+      return fileName.slice(0, -ext.length) + declarationExtsRemapping[ext];
+    }
+    function getDeclarationFiles(rootFiles, compilerOptions, host) {
+      compilerOptions = {
+        ...compilerOptions,
+        noEmit: false,
+        declaration: true,
+        emitDeclarationOnly: true
+      };
+      const program = ts2.createProgram(rootFiles, compilerOptions, host);
+      const allFilesAreDeclarations = program.getSourceFiles().every((s) => s.isDeclarationFile);
+      const declarations = /* @__PURE__ */ new Map();
+      if (allFilesAreDeclarations) {
+        (0, logger_1.verboseLog)("Skipping compiling the project to generate d.ts because all files in it are d.ts already");
+        return declarations;
+      }
+      (0, check_diagnostics_errors_1.checkProgramDiagnosticsErrors)(program);
+      const emitResult = program.emit(void 0, (fileName, data) => declarations.set(host.getCanonicalFileName(fileName), data), void 0, true);
+      (0, check_diagnostics_errors_1.checkDiagnosticsErrors)(emitResult.diagnostics, "Errors while emitting declarations");
+      return declarations;
+    }
+    function warnAboutTypeScriptFilesInProgram(program) {
+      const nonDeclarationFiles = program.getSourceFiles().filter((file) => !file.isDeclarationFile);
+      if (nonDeclarationFiles.length !== 0) {
+        (0, logger_1.warnLog)(`WARNING: It seems that some files in the compilation still are not declaration files.
+For more information see https://github.com/timocov/dts-bundle-generator/issues/53.
+If you think this is a mistake, feel free to open new issue or just ignore this warning.
+  ${nonDeclarationFiles.map((file) => file.fileName).join("\n  ")}
+`);
+      }
+    }
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/typescript.js
+var require_typescript = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/typescript.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.resolveGlobalName = exports.getDeclarationsForExportedValues = exports.getSymbolExportStarDeclarations = exports.getImportExportReferencedSymbol = exports.getImportModuleName = exports.resolveReferencedModule = exports.getClosestSourceFileLikeNode = exports.getClosestModuleLikeNode = exports.getNodeSymbol = exports.getNodeOwnSymbol = exports.getRootSourceFile = exports.getModifiers = exports.recreateRootLevelNodeWithModifiers = exports.modifiersMapToArray = exports.modifiersToMap = exports.getExportsForStatement = exports.resolveIdentifier = exports.getExportsForSourceFile = exports.getDeclarationsForSymbol = exports.isDeclareGlobalStatement = exports.isDeclareModule = exports.isAmbientModule = exports.splitTransientSymbol = exports.getDeclarationNameSymbol = exports.getActualSymbol = exports.getNodeName = exports.hasNodeModifier = exports.isNodeNamedDeclaration = void 0;
+    var ts2 = __require("typescript");
+    var logger_1 = require_logger();
+    var namedDeclarationKinds = [
+      ts2.SyntaxKind.InterfaceDeclaration,
+      ts2.SyntaxKind.ClassDeclaration,
+      ts2.SyntaxKind.EnumDeclaration,
+      ts2.SyntaxKind.TypeAliasDeclaration,
+      ts2.SyntaxKind.ModuleDeclaration,
+      ts2.SyntaxKind.FunctionDeclaration,
+      ts2.SyntaxKind.VariableDeclaration,
+      ts2.SyntaxKind.PropertySignature,
+      ts2.SyntaxKind.NamespaceExport,
+      ts2.SyntaxKind.NamespaceImport,
+      ts2.SyntaxKind.ExportSpecifier,
+      ts2.SyntaxKind.BindingElement
+    ];
+    function isNodeNamedDeclaration(node) {
+      return namedDeclarationKinds.indexOf(node.kind) !== -1;
+    }
+    exports.isNodeNamedDeclaration = isNodeNamedDeclaration;
+    function hasNodeModifier(node, modifier) {
+      const modifiers = getModifiers(node);
+      return Boolean(modifiers && modifiers.some((nodeModifier) => nodeModifier.kind === modifier));
+    }
+    exports.hasNodeModifier = hasNodeModifier;
+    function getNodeName(node) {
+      const nodeName = node.name;
+      if (nodeName === void 0) {
+        const modifiers = getModifiers(node);
+        const defaultModifier = modifiers?.find((mod) => mod.kind === ts2.SyntaxKind.DefaultKeyword);
+        if (defaultModifier !== void 0) {
+          return defaultModifier;
+        }
+      }
+      return nodeName;
+    }
+    exports.getNodeName = getNodeName;
+    function getActualSymbol(symbol, typeChecker) {
+      if (symbol.flags & ts2.SymbolFlags.Alias) {
+        symbol = typeChecker.getAliasedSymbol(symbol);
+      }
+      return typeChecker.getMergedSymbol(symbol);
+    }
+    exports.getActualSymbol = getActualSymbol;
+    function getDeclarationNameSymbol(name, typeChecker) {
+      const symbol = typeChecker.getSymbolAtLocation(name);
+      if (symbol === void 0) {
+        return null;
+      }
+      return getActualSymbol(symbol, typeChecker);
+    }
+    exports.getDeclarationNameSymbol = getDeclarationNameSymbol;
+    function splitTransientSymbol(symbol, typeChecker) {
+      if ((symbol.flags & ts2.SymbolFlags.Transient) === 0) {
+        return /* @__PURE__ */ new Set([symbol]);
+      }
+      const declarations = getDeclarationsForSymbol(symbol);
+      const result = /* @__PURE__ */ new Set();
+      for (const declaration of declarations) {
+        if (!isNodeNamedDeclaration(declaration) || declaration.name === void 0) {
+          continue;
+        }
+        const sym = typeChecker.getSymbolAtLocation(declaration.name);
+        if (sym === void 0) {
+          continue;
+        }
+        result.add(getActualSymbol(sym, typeChecker));
+      }
+      return result;
+    }
+    exports.splitTransientSymbol = splitTransientSymbol;
+    function isGlobalScopeAugmentation(module2) {
+      return Boolean(module2.flags & ts2.NodeFlags.GlobalAugmentation);
+    }
+    function isAmbientModule(node) {
+      return ts2.isModuleDeclaration(node) && (node.name.kind === ts2.SyntaxKind.StringLiteral || isGlobalScopeAugmentation(node));
+    }
+    exports.isAmbientModule = isAmbientModule;
+    function isDeclareModule(node) {
+      return ts2.isModuleDeclaration(node) && !(node.flags & ts2.NodeFlags.Namespace) && !isGlobalScopeAugmentation(node);
+    }
+    exports.isDeclareModule = isDeclareModule;
+    function isDeclareGlobalStatement(statement) {
+      return ts2.isModuleDeclaration(statement) && isGlobalScopeAugmentation(statement);
+    }
+    exports.isDeclareGlobalStatement = isDeclareGlobalStatement;
+    function getDeclarationsForSymbol(symbol) {
+      const result = [];
+      if (symbol.declarations !== void 0) {
+        result.push(...symbol.declarations);
+      }
+      if (symbol.valueDeclaration !== void 0) {
+        if (!result.includes(symbol.valueDeclaration)) {
+          result.push(symbol.valueDeclaration);
+        }
+      }
+      return result;
+    }
+    exports.getDeclarationsForSymbol = getDeclarationsForSymbol;
+    function getExportsForSourceFile(typeChecker, sourceFileSymbol) {
+      if (sourceFileSymbol.exports !== void 0) {
+        const commonJsExport = sourceFileSymbol.exports.get(ts2.InternalSymbolName.ExportEquals);
+        if (commonJsExport !== void 0) {
+          const symbol = getActualSymbol(commonJsExport, typeChecker);
+          return [
+            {
+              symbol,
+              originalSymbol: commonJsExport,
+              type: 0,
+              exportedName: ""
+            }
+          ];
+        }
+      }
+      const result = typeChecker.getExportsOfModule(sourceFileSymbol).map((symbol) => ({
+        symbol,
+        originalSymbol: symbol,
+        exportedName: symbol.name,
+        type: 1
+        /* ExportType.ES6Named */
+      }));
+      if (sourceFileSymbol.exports !== void 0) {
+        const defaultExportSymbol = sourceFileSymbol.exports.get(ts2.InternalSymbolName.Default);
+        if (defaultExportSymbol !== void 0) {
+          const defaultExport = result.find((exp) => exp.symbol === defaultExportSymbol);
+          if (defaultExport !== void 0) {
+            defaultExport.type = 2;
+          } else {
+            result.push({
+              symbol: defaultExportSymbol,
+              originalSymbol: defaultExportSymbol,
+              type: 2,
+              exportedName: "default"
+            });
+          }
+        }
+      }
+      const symbolsMergingResolvedExports = [];
+      result.forEach((exp) => {
+        exp.symbol = getActualSymbol(exp.symbol, typeChecker);
+        const symbolsDeclarations = getDeclarationsForSymbol(exp.symbol);
+        const importSpecifierDeclaration = symbolsDeclarations.find(ts2.isImportSpecifier);
+        if (symbolsDeclarations.length > 1 && importSpecifierDeclaration !== void 0) {
+          const referencedModule = resolveReferencedModule(importSpecifierDeclaration.parent.parent.parent, typeChecker);
+          if (referencedModule !== null) {
+            const referencedModuleSymbol = getNodeSymbol(referencedModule, typeChecker);
+            if (referencedModuleSymbol !== null) {
+              const importedName = (importSpecifierDeclaration.propertyName ?? importSpecifierDeclaration.name).getText();
+              const exportedItemSymbol = typeChecker.getExportsOfModule(referencedModuleSymbol).find((exportSymbol) => exportSymbol.getName() === importedName);
+              if (exportedItemSymbol !== void 0) {
+                symbolsMergingResolvedExports.push({
+                  ...exp,
+                  symbol: getActualSymbol(exportedItemSymbol, typeChecker)
+                });
+              }
+            }
+          }
+        }
+      });
+      return [...result, ...symbolsMergingResolvedExports];
+    }
+    exports.getExportsForSourceFile = getExportsForSourceFile;
+    function resolveIdentifier(typeChecker, identifier) {
+      const symbol = getDeclarationNameSymbol(identifier, typeChecker);
+      if (symbol === null) {
+        return void 0;
+      }
+      return resolveDeclarationByIdentifierSymbol(symbol);
+    }
+    exports.resolveIdentifier = resolveIdentifier;
+    function resolveDeclarationByIdentifierSymbol(identifierSymbol) {
+      const declarations = getDeclarationsForSymbol(identifierSymbol);
+      if (declarations.length === 0) {
+        return void 0;
+      }
+      const decl = declarations[0];
+      if (!isNodeNamedDeclaration(decl)) {
+        return void 0;
+      }
+      return decl;
+    }
+    function getExportsForStatement(exportedSymbols, typeChecker, statement) {
+      if (ts2.isVariableStatement(statement)) {
+        if (statement.declarationList.declarations.length === 0) {
+          return [];
+        }
+        const firstDeclarationExports = getExportsForName(exportedSymbols, typeChecker, statement.declarationList.declarations[0].name);
+        const allDeclarationsHaveSameExportType = statement.declarationList.declarations.every((variableDecl) => {
+          return getExportsForName(exportedSymbols, typeChecker, variableDecl.name)[0]?.type === firstDeclarationExports[0]?.type;
+        });
+        if (!allDeclarationsHaveSameExportType) {
+          return [];
+        }
+        return firstDeclarationExports;
+      }
+      const nodeName = getNodeName(statement);
+      if (nodeName === void 0) {
+        return [];
+      }
+      return getExportsForName(exportedSymbols, typeChecker, nodeName);
+    }
+    exports.getExportsForStatement = getExportsForStatement;
+    function getExportsForName(exportedSymbols, typeChecker, name) {
+      if (ts2.isArrayBindingPattern(name) || ts2.isObjectBindingPattern(name)) {
+        return [];
+      }
+      const declarationSymbol = typeChecker.getSymbolAtLocation(name);
+      return exportedSymbols.filter((rootExport) => rootExport.symbol === declarationSymbol);
+    }
+    var modifiersPriority = {
+      [ts2.SyntaxKind.ExportKeyword]: 4,
+      [ts2.SyntaxKind.DefaultKeyword]: 3,
+      [ts2.SyntaxKind.DeclareKeyword]: 2,
+      [ts2.SyntaxKind.AsyncKeyword]: 1,
+      [ts2.SyntaxKind.ConstKeyword]: 1
+    };
+    function modifiersToMap(modifiers) {
+      modifiers = modifiers || [];
+      return modifiers.reduce(
+        (result, modifier) => {
+          result[modifier.kind] = true;
+          return result;
+        },
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        {}
+      );
+    }
+    exports.modifiersToMap = modifiersToMap;
+    function modifiersMapToArray(modifiersMap) {
+      return Object.entries(modifiersMap).filter(([kind, include]) => include).map(([kind]) => {
+        return ts2.factory.createModifier(Number(kind));
+      }).sort((a, b) => {
+        const aValue = modifiersPriority[a.kind] || 0;
+        const bValue = modifiersPriority[b.kind] || 0;
+        return bValue - aValue;
+      });
+    }
+    exports.modifiersMapToArray = modifiersMapToArray;
+    function recreateRootLevelNodeWithModifiers(node, modifiersMap, newName, keepComments = true) {
+      const newNode = recreateRootLevelNodeWithModifiersImpl(node, modifiersMap, newName);
+      if (keepComments) {
+        ts2.setCommentRange(newNode, ts2.getCommentRange(node));
+      }
+      return newNode;
+    }
+    exports.recreateRootLevelNodeWithModifiers = recreateRootLevelNodeWithModifiers;
+    function recreateRootLevelNodeWithModifiersImpl(node, modifiersMap, newName) {
+      const modifiers = modifiersMapToArray(modifiersMap);
+      if (ts2.isArrowFunction(node)) {
+        return ts2.factory.createArrowFunction(modifiers, node.typeParameters, node.parameters, node.type, node.equalsGreaterThanToken, node.body);
+      }
+      if (ts2.isClassDeclaration(node)) {
+        return ts2.factory.createClassDeclaration(modifiers, newName || node.name, node.typeParameters, node.heritageClauses, node.members);
+      }
+      if (ts2.isClassExpression(node)) {
+        return ts2.factory.createClassExpression(modifiers, newName || node.name, node.typeParameters, node.heritageClauses, node.members);
+      }
+      if (ts2.isEnumDeclaration(node)) {
+        return ts2.factory.createEnumDeclaration(modifiers, newName || node.name, node.members);
+      }
+      if (ts2.isExportAssignment(node)) {
+        return ts2.factory.createExportAssignment(modifiers, node.isExportEquals, node.expression);
+      }
+      if (ts2.isExportDeclaration(node)) {
+        return ts2.factory.createExportDeclaration(
+          modifiers,
+          node.isTypeOnly,
+          node.exportClause,
+          node.moduleSpecifier,
+          // eslint-disable-next-line deprecation/deprecation
+          node.attributes || node.assertClause
+        );
+      }
+      if (ts2.isFunctionDeclaration(node)) {
+        return ts2.factory.createFunctionDeclaration(modifiers, node.asteriskToken, newName || node.name, node.typeParameters, node.parameters, node.type, node.body);
+      }
+      if (ts2.isFunctionExpression(node)) {
+        return ts2.factory.createFunctionExpression(modifiers, node.asteriskToken, newName || node.name, node.typeParameters, node.parameters, node.type, node.body);
+      }
+      if (ts2.isImportDeclaration(node)) {
+        return ts2.factory.createImportDeclaration(
+          modifiers,
+          node.importClause,
+          node.moduleSpecifier,
+          // eslint-disable-next-line deprecation/deprecation
+          node.attributes || node.assertClause
+        );
+      }
+      if (ts2.isImportEqualsDeclaration(node)) {
+        return ts2.factory.createImportEqualsDeclaration(modifiers, node.isTypeOnly, newName || node.name, node.moduleReference);
+      }
+      if (ts2.isInterfaceDeclaration(node)) {
+        return ts2.factory.createInterfaceDeclaration(modifiers, newName || node.name, node.typeParameters, node.heritageClauses, node.members);
+      }
+      if (ts2.isModuleDeclaration(node)) {
+        return ts2.factory.createModuleDeclaration(modifiers, node.name, node.body, node.flags);
+      }
+      if (ts2.isTypeAliasDeclaration(node)) {
+        return ts2.factory.createTypeAliasDeclaration(modifiers, newName || node.name, node.typeParameters, node.type);
+      }
+      if (ts2.isVariableStatement(node)) {
+        return ts2.factory.createVariableStatement(modifiers, node.declarationList);
+      }
+      throw new Error(`Unknown top-level node kind (with modifiers): ${ts2.SyntaxKind[node.kind]}.
+If you're seeing this error, please report a bug on https://github.com/timocov/dts-bundle-generator/issues`);
+    }
+    function getModifiers(node) {
+      if (!ts2.canHaveModifiers(node)) {
+        return void 0;
+      }
+      return ts2.getModifiers(node);
+    }
+    exports.getModifiers = getModifiers;
+    function getRootSourceFile(program, rootFileName) {
+      if (program.getRootFileNames().indexOf(rootFileName) === -1) {
+        throw new Error(`There is no such root file ${rootFileName}`);
+      }
+      const sourceFile = program.getSourceFile(rootFileName);
+      if (sourceFile === void 0) {
+        throw new Error(`Cannot get source file for root file ${rootFileName}`);
+      }
+      return sourceFile;
+    }
+    exports.getRootSourceFile = getRootSourceFile;
+    function getNodeOwnSymbol(node, typeChecker) {
+      const nodeSymbol = typeChecker.getSymbolAtLocation(node);
+      if (nodeSymbol === void 0) {
+        throw new Error(`Cannot find symbol for node "${node.getText()}" in "${node.parent.getText()}" from "${node.getSourceFile().fileName}"`);
+      }
+      return nodeSymbol;
+    }
+    exports.getNodeOwnSymbol = getNodeOwnSymbol;
+    function getNodeSymbol(node, typeChecker) {
+      if (ts2.isSourceFile(node)) {
+        const fileSymbol = typeChecker.getSymbolAtLocation(node);
+        if (fileSymbol === void 0) {
+          return null;
+        }
+        return getActualSymbol(fileSymbol, typeChecker);
+      }
+      const nodeName = getNodeName(node);
+      if (nodeName === void 0) {
+        return null;
+      }
+      return getDeclarationNameSymbol(nodeName, typeChecker);
+    }
+    exports.getNodeSymbol = getNodeSymbol;
+    function getClosestModuleLikeNode(node) {
+      while (!ts2.isModuleBlock(node) && !ts2.isSourceFile(node)) {
+        node = node.parent;
+      }
+      return ts2.isSourceFile(node) ? node : node.parent;
+    }
+    exports.getClosestModuleLikeNode = getClosestModuleLikeNode;
+    function getClosestSourceFileLikeNode(node) {
+      while (!(ts2.isModuleBlock(node) && ts2.isStringLiteral(node.parent.name)) && !ts2.isSourceFile(node)) {
+        node = node.parent;
+      }
+      return ts2.isSourceFile(node) ? node : node.parent;
+    }
+    exports.getClosestSourceFileLikeNode = getClosestSourceFileLikeNode;
+    function resolveReferencedModule(node, typeChecker) {
+      let moduleName;
+      if (ts2.isExportDeclaration(node) || ts2.isImportDeclaration(node)) {
+        moduleName = node.moduleSpecifier;
+      } else if (ts2.isModuleDeclaration(node)) {
+        moduleName = node.name;
+      } else if (ts2.isImportEqualsDeclaration(node)) {
+        if (ts2.isExternalModuleReference(node.moduleReference)) {
+          moduleName = node.moduleReference.expression;
+        }
+      } else if (ts2.isLiteralTypeNode(node.argument) && ts2.isStringLiteral(node.argument.literal)) {
+        moduleName = node.argument.literal;
+      }
+      if (moduleName === void 0) {
+        return null;
+      }
+      const moduleSymbol = typeChecker.getSymbolAtLocation(moduleName);
+      if (moduleSymbol === void 0) {
+        return null;
+      }
+      const symbol = getActualSymbol(moduleSymbol, typeChecker);
+      if (symbol.valueDeclaration === void 0) {
+        return null;
+      }
+      return ts2.isSourceFile(symbol.valueDeclaration) || ts2.isModuleDeclaration(symbol.valueDeclaration) ? symbol.valueDeclaration : null;
+    }
+    exports.resolveReferencedModule = resolveReferencedModule;
+    function getImportModuleName(imp) {
+      if (ts2.isImportDeclaration(imp)) {
+        return imp.importClause === void 0 ? null : imp.moduleSpecifier.text;
+      }
+      if (ts2.isExportDeclaration(imp)) {
+        return imp.moduleSpecifier === void 0 ? null : imp.moduleSpecifier.text;
+      }
+      if (ts2.isExternalModuleReference(imp.moduleReference)) {
+        if (!ts2.isStringLiteral(imp.moduleReference.expression)) {
+          (0, logger_1.warnLog)(`Cannot handle non string-literal-like import expression: ${imp.moduleReference.expression.getText()}`);
+          return null;
+        }
+        return imp.moduleReference.expression.text;
+      }
+      return null;
+    }
+    exports.getImportModuleName = getImportModuleName;
+    function getImportExportReferencedSymbol(importExportSpecifier, typeChecker) {
+      return importExportSpecifier.propertyName !== void 0 ? typeChecker.getSymbolAtLocation(importExportSpecifier.propertyName) : typeChecker.getImmediateAliasedSymbol(typeChecker.getSymbolAtLocation(importExportSpecifier.name));
+    }
+    exports.getImportExportReferencedSymbol = getImportExportReferencedSymbol;
+    function getSymbolExportStarDeclarations(symbol) {
+      if (symbol.escapedName !== ts2.InternalSymbolName.ExportStar) {
+        throw new Error(`Only ExportStar symbol can have export star declaration, but got ${symbol.escapedName}`);
+      }
+      return getDeclarationsForSymbol(symbol).filter((decl) => ts2.isExportDeclaration(decl) && decl.moduleSpecifier !== void 0);
+    }
+    exports.getSymbolExportStarDeclarations = getSymbolExportStarDeclarations;
+    function getDeclarationsForExportedValues(exp, typeChecker) {
+      const nodeForSymbol = ts2.isExportAssignment(exp) ? exp.expression : exp.moduleSpecifier;
+      if (nodeForSymbol === void 0) {
+        return [];
+      }
+      const symbolForExpression = typeChecker.getSymbolAtLocation(nodeForSymbol);
+      if (symbolForExpression === void 0) {
+        return [];
+      }
+      const symbol = getActualSymbol(symbolForExpression, typeChecker);
+      return getDeclarationsForSymbol(symbol);
+    }
+    exports.getDeclarationsForExportedValues = getDeclarationsForExportedValues;
+    function resolveGlobalName(typeChecker, name) {
+      const tsSymbolFlagsAll = (
+        /* ts.SymbolFlags.All */
+        -1
+      );
+      return typeChecker.resolveName(name, void 0, tsSymbolFlagsAll, false);
+    }
+    exports.resolveGlobalName = resolveGlobalName;
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/types-usage-evaluator.js
+var require_types_usage_evaluator = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/types-usage-evaluator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TypesUsageEvaluator = void 0;
+    var ts2 = __require("typescript");
+    var typescript_1 = require_typescript();
+    var TypesUsageEvaluator = class {
+      constructor(files, typeChecker) {
+        this.nodesParentsMap = /* @__PURE__ */ new Map();
+        this.usageResultCache = /* @__PURE__ */ new Map();
+        this.typeChecker = typeChecker;
+        this.computeUsages(files);
+      }
+      isSymbolUsedBySymbol(symbol, by) {
+        return this.isSymbolUsedBySymbolImpl(this.getActualSymbol(symbol), this.getActualSymbol(by), /* @__PURE__ */ new Set());
+      }
+      getSymbolsUsingSymbol(symbol) {
+        return this.nodesParentsMap.get(this.getActualSymbol(symbol)) || null;
+      }
+      isSymbolUsedBySymbolImpl(fromSymbol, toSymbol, visitedSymbols) {
+        if (fromSymbol === toSymbol) {
+          return this.setUsageCacheValue(fromSymbol, toSymbol, true);
+        }
+        const cacheResult = this.usageResultCache.get(fromSymbol)?.get(toSymbol);
+        if (cacheResult !== void 0) {
+          return cacheResult;
+        }
+        const reachableNodes = this.nodesParentsMap.get(fromSymbol);
+        if (reachableNodes !== void 0) {
+          for (const symbol of reachableNodes) {
+            if (visitedSymbols.has(symbol)) {
+              continue;
+            }
+            visitedSymbols.add(symbol);
+            if (this.isSymbolUsedBySymbolImpl(symbol, toSymbol, visitedSymbols)) {
+              return this.setUsageCacheValue(fromSymbol, toSymbol, true);
+            }
+          }
+        }
+        visitedSymbols.add(fromSymbol);
+        return false;
+      }
+      setUsageCacheValue(fromSymbol, toSymbol, value) {
+        let fromSymbolCacheMap = this.usageResultCache.get(fromSymbol);
+        if (fromSymbolCacheMap === void 0) {
+          fromSymbolCacheMap = /* @__PURE__ */ new Map();
+          this.usageResultCache.set(fromSymbol, fromSymbolCacheMap);
+        }
+        fromSymbolCacheMap.set(toSymbol, value);
+        return value;
+      }
+      computeUsages(files) {
+        this.nodesParentsMap.clear();
+        for (const file of files) {
+          ts2.forEachChild(file, this.computeUsageForNode.bind(this));
+        }
+      }
+      // eslint-disable-next-line complexity
+      computeUsageForNode(node) {
+        if ((0, typescript_1.isDeclareModule)(node) && node.body !== void 0 && ts2.isModuleBlock(node.body)) {
+          const moduleSymbol = this.getSymbol(node.name);
+          for (const statement of node.body.statements) {
+            this.computeUsageForNode(statement);
+            if ((0, typescript_1.isNodeNamedDeclaration)(statement)) {
+              const nodeName = (0, typescript_1.getNodeName)(statement);
+              if (nodeName !== void 0) {
+                const statementSymbol = this.getSymbol(nodeName);
+                this.addUsages(statementSymbol, moduleSymbol);
+              }
+            }
+          }
+        }
+        if ((0, typescript_1.isNodeNamedDeclaration)(node)) {
+          const nodeName = (0, typescript_1.getNodeName)(node);
+          if (nodeName !== void 0) {
+            if (ts2.isObjectBindingPattern(nodeName) || ts2.isArrayBindingPattern(nodeName)) {
+              for (const element of nodeName.elements) {
+                this.computeUsageForNode(element);
+              }
+            } else {
+              const childSymbol = this.getSymbol(nodeName);
+              if (childSymbol !== null) {
+                this.computeUsagesRecursively(node, childSymbol);
+              }
+            }
+          }
+        }
+        if (ts2.isVariableStatement(node)) {
+          for (const varDeclaration of node.declarationList.declarations) {
+            this.computeUsageForNode(varDeclaration);
+          }
+        }
+        if (ts2.isExportDeclaration(node) && node.moduleSpecifier !== void 0 && node.exportClause !== void 0 && ts2.isNamespaceExport(node.exportClause)) {
+          this.addUsagesForNamespacedModule(node.exportClause, node.moduleSpecifier);
+        }
+        if (ts2.isImportDeclaration(node) && node.moduleSpecifier !== void 0 && node.importClause?.namedBindings !== void 0 && ts2.isNamespaceImport(node.importClause.namedBindings)) {
+          this.addUsagesForNamespacedModule(node.importClause.namedBindings, node.moduleSpecifier, false);
+        }
+        if (ts2.isExportDeclaration(node) && node.exportClause !== void 0 && ts2.isNamedExports(node.exportClause)) {
+          for (const exportElement of node.exportClause.elements) {
+            const exportElementSymbol = (0, typescript_1.getImportExportReferencedSymbol)(exportElement, this.typeChecker);
+            const namespaceImportForElement = (0, typescript_1.getDeclarationsForSymbol)(exportElementSymbol).find(ts2.isNamespaceImport);
+            if (namespaceImportForElement !== void 0) {
+              this.addUsagesForNamespacedModule(namespaceImportForElement, namespaceImportForElement.parent.parent.moduleSpecifier);
+            }
+            const exportElementOwnSymbol = this.getNodeOwnSymbol(exportElement.name);
+            this.addUsages(exportElementSymbol, exportElementOwnSymbol);
+            this.addUsages(this.getActualSymbol(exportElementSymbol), exportElementOwnSymbol);
+          }
+        }
+        if (ts2.isExportAssignment(node) && node.isExportEquals) {
+          this.addUsagesForExportAssignment(node);
+        }
+      }
+      addUsagesForExportAssignment(exportAssignment) {
+        for (const declaration of (0, typescript_1.getDeclarationsForExportedValues)(exportAssignment, this.typeChecker)) {
+          if (ts2.isModuleDeclaration(declaration) && ts2.isIdentifier(declaration.name) && declaration.body !== void 0 && ts2.isModuleBlock(declaration.body)) {
+            const moduleSymbol = this.getSymbol(declaration.name);
+            for (const statement of declaration.body.statements) {
+              if ((0, typescript_1.isNodeNamedDeclaration)(statement) && statement.name !== void 0) {
+                const statementSymbol = this.getSymbol(statement.name);
+                if (statementSymbol !== null) {
+                  this.addUsages(moduleSymbol, statementSymbol);
+                }
+              }
+            }
+          }
+        }
+      }
+      addUsagesForNamespacedModule(namespaceNode, moduleSpecifier, includeExports = true) {
+        const namespaceSymbol = this.getNodeOwnSymbol(namespaceNode.name);
+        const referencedSourceFileSymbol = this.getSymbol(moduleSpecifier);
+        this.addUsages(referencedSourceFileSymbol, namespaceSymbol);
+        const resolvedNamespaceSymbol = this.getSymbol(namespaceNode.name);
+        this.addUsages(resolvedNamespaceSymbol, namespaceSymbol);
+        if (includeExports) {
+          this.addExportsToSymbol(referencedSourceFileSymbol.exports, referencedSourceFileSymbol);
+        }
+      }
+      addExportsToSymbol(exports2, parentSymbol, visitedSymbols = /* @__PURE__ */ new Set()) {
+        exports2?.forEach((moduleExportedSymbol, name) => {
+          if (name === ts2.InternalSymbolName.ExportStar) {
+            for (const exportStarDeclaration of (0, typescript_1.getSymbolExportStarDeclarations)(moduleExportedSymbol)) {
+              if (exportStarDeclaration.moduleSpecifier === void 0) {
+                throw new Error(`Export star declaration does not have a module specifier '${exportStarDeclaration.getText()}'`);
+              }
+              const referencedSourceFileSymbol = this.getSymbol(exportStarDeclaration.moduleSpecifier);
+              if (visitedSymbols.has(referencedSourceFileSymbol)) {
+                continue;
+              }
+              visitedSymbols.add(referencedSourceFileSymbol);
+              this.addExportsToSymbol(referencedSourceFileSymbol.exports, parentSymbol, visitedSymbols);
+            }
+            return;
+          }
+          this.addUsages(moduleExportedSymbol, parentSymbol);
+        });
+      }
+      computeUsagesRecursively(parent, parentSymbol) {
+        ts2.forEachChild(parent, (child) => {
+          if (child.kind === ts2.SyntaxKind.JSDoc) {
+            return;
+          }
+          this.computeUsagesRecursively(child, parentSymbol);
+          if (ts2.isIdentifier(child) || child.kind === ts2.SyntaxKind.DefaultKeyword) {
+            if (ts2.isNamedTupleMember(child.parent) && child.parent.name === child) {
+              return;
+            }
+            if (ts2.isBindingElement(child.parent) && child.parent.propertyName === child) {
+              return;
+            }
+            this.addUsages(this.getSymbol(child), parentSymbol);
+            if (!ts2.isQualifiedName(child.parent)) {
+              const childOwnSymbol = this.getNodeOwnSymbol(child);
+              const namespaceImport = (0, typescript_1.getDeclarationsForSymbol)(childOwnSymbol).find(ts2.isNamespaceImport);
+              if (namespaceImport !== void 0) {
+                this.addUsagesForNamespacedModule(namespaceImport, namespaceImport.parent.parent.moduleSpecifier, true);
+              }
+            }
+          }
+        });
+      }
+      addUsages(childSymbol, parentSymbol) {
+        const childSymbols = (0, typescript_1.splitTransientSymbol)(childSymbol, this.typeChecker);
+        for (const childSplitSymbol of childSymbols) {
+          let symbols = this.nodesParentsMap.get(childSplitSymbol);
+          if (symbols === void 0) {
+            symbols = /* @__PURE__ */ new Set();
+            this.nodesParentsMap.set(childSplitSymbol, symbols);
+          }
+          if (childSplitSymbol !== parentSymbol) {
+            symbols.add(parentSymbol);
+          }
+        }
+      }
+      getSymbol(node) {
+        return this.getActualSymbol(this.getNodeOwnSymbol(node));
+      }
+      getNodeOwnSymbol(node) {
+        return (0, typescript_1.getNodeOwnSymbol)(node, this.typeChecker);
+      }
+      getActualSymbol(symbol) {
+        return (0, typescript_1.getActualSymbol)(symbol, this.typeChecker);
+      }
+    };
+    exports.TypesUsageEvaluator = TypesUsageEvaluator;
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/node-modules.js
+var require_node_modules = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/node-modules.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getTypesLibraryName = exports.getLibraryName = void 0;
+    var nodeModulesFolderName = "node_modules/";
+    var libraryNameRegex = /node_modules\/((?:(?=@)[^/]+\/[^/]+|[^/]+))\//;
+    function getLibraryName(fileName) {
+      const lastNodeModulesIndex = fileName.lastIndexOf(nodeModulesFolderName);
+      if (lastNodeModulesIndex === -1) {
+        return null;
+      }
+      const match = libraryNameRegex.exec(fileName.slice(lastNodeModulesIndex));
+      if (match === null) {
+        return null;
+      }
+      return match[1];
+    }
+    exports.getLibraryName = getLibraryName;
+    function getTypesLibraryName(path2) {
+      const libraryName = getLibraryName(path2);
+      if (libraryName === null) {
+        return null;
+      }
+      const typesFolderPrefix = "@types/";
+      if (!libraryName.startsWith(typesFolderPrefix)) {
+        return null;
+      }
+      return libraryName.substring(typesFolderPrefix.length);
+    }
+    exports.getTypesLibraryName = getTypesLibraryName;
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/module-info.js
+var require_module_info = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/module-info.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getModuleLikeModuleInfo = exports.getReferencedModuleInfo = exports.getFileModuleInfo = void 0;
+    var path2 = __require("path");
+    var ts2 = __require("typescript");
+    var node_modules_1 = require_node_modules();
+    var fix_path_1 = require_fix_path();
+    var typescript_1 = require_typescript();
+    function getFileModuleInfo(fileName, criteria) {
+      return getModuleInfoImpl(fileName, fileName, criteria);
+    }
+    exports.getFileModuleInfo = getFileModuleInfo;
+    function getReferencedModuleInfo(moduleDecl, criteria, typeChecker) {
+      const referencedModule = (0, typescript_1.resolveReferencedModule)(moduleDecl, typeChecker);
+      if (referencedModule === null) {
+        return null;
+      }
+      const moduleFilePath = ts2.isSourceFile(referencedModule) ? referencedModule.fileName : resolveModuleFileName(referencedModule.getSourceFile().fileName, referencedModule.name.text);
+      return getFileModuleInfo(moduleFilePath, criteria);
+    }
+    exports.getReferencedModuleInfo = getReferencedModuleInfo;
+    function getModuleLikeModuleInfo(moduleLike, criteria, typeChecker) {
+      const resolvedModuleLike = ts2.isSourceFile(moduleLike) ? moduleLike : (0, typescript_1.resolveReferencedModule)(moduleLike, typeChecker) ?? moduleLike;
+      const fileName = ts2.isSourceFile(resolvedModuleLike) ? resolvedModuleLike.fileName : resolveModuleFileName(resolvedModuleLike.getSourceFile().fileName, resolvedModuleLike.name.text);
+      return getFileModuleInfo(fileName, criteria);
+    }
+    exports.getModuleLikeModuleInfo = getModuleLikeModuleInfo;
+    function resolveModuleFileName(currentFileName, moduleName) {
+      return moduleName.startsWith(".") ? (0, fix_path_1.fixPath)(path2.join(currentFileName, "..", moduleName)) : `node_modules/${moduleName}/`;
+    }
+    function getModuleInfoImpl(currentFilePath, originalFileName, criteria) {
+      const npmLibraryName = (0, node_modules_1.getLibraryName)(currentFilePath);
+      if (npmLibraryName === null) {
+        if (criteria.typeRoots !== void 0) {
+          for (const root of criteria.typeRoots) {
+            const relativePath = (0, fix_path_1.fixPath)(path2.relative(root, originalFileName));
+            if (!relativePath.startsWith("../")) {
+              return getModuleInfoImpl(remapToTypesFromNodeModules(relativePath), originalFileName, criteria);
+            }
+          }
+        }
+        return { type: 0, fileName: originalFileName, isExternal: false };
+      }
+      const typesLibraryName = (0, node_modules_1.getTypesLibraryName)(currentFilePath);
+      if (shouldLibraryBeInlined(npmLibraryName, typesLibraryName, criteria.inlinedLibraries)) {
+        return { type: 0, fileName: originalFileName, isExternal: true };
+      }
+      if (shouldLibraryBeImported(npmLibraryName, typesLibraryName, criteria.importedLibraries, criteria.allowedTypesLibraries)) {
+        return { type: 1, fileName: originalFileName, isExternal: true };
+      }
+      if (typesLibraryName !== null && isLibraryAllowed(typesLibraryName, criteria.allowedTypesLibraries)) {
+        return { type: 2, fileName: originalFileName, typesLibraryName, isExternal: true };
+      }
+      return { type: 3, fileName: originalFileName, isExternal: true };
+    }
+    function shouldLibraryBeInlined(npmLibraryName, typesLibraryName, inlinedLibraries) {
+      return isLibraryAllowed(npmLibraryName, inlinedLibraries) || typesLibraryName !== null && isLibraryAllowed(typesLibraryName, inlinedLibraries);
+    }
+    function shouldLibraryBeImported(npmLibraryName, typesLibraryName, importedLibraries, allowedTypesLibraries) {
+      if (typesLibraryName === null) {
+        return isLibraryAllowed(npmLibraryName, importedLibraries);
+      }
+      if (allowedTypesLibraries === void 0 || !isLibraryAllowed(typesLibraryName, allowedTypesLibraries)) {
+        return isLibraryAllowed(typesLibraryName, importedLibraries);
+      }
+      return false;
+    }
+    function isLibraryAllowed(libraryName, allowedArray) {
+      return allowedArray === void 0 || allowedArray.indexOf(libraryName) !== -1;
+    }
+    function remapToTypesFromNodeModules(pathRelativeToTypesRoot) {
+      return `node_modules/@types/${pathRelativeToTypesRoot}`;
+    }
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/package-version.js
+var require_package_version = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/helpers/package-version.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.packageVersion = void 0;
+    var fs = __require("fs");
+    var path2 = __require("path");
+    function packageVersion() {
+      let dirName = __dirname;
+      while (dirName.length !== 0) {
+        const packageJsonFilePath = path2.join(dirName, "package.json");
+        if (fs.existsSync(packageJsonFilePath)) {
+          return __require(packageJsonFilePath).version;
+        }
+        dirName = path2.join(dirName, "..");
+      }
+      throw new Error(`Cannot find up package.json in ${__dirname}`);
+    }
+    exports.packageVersion = packageVersion;
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/generate-output.js
+var require_generate_output = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/generate-output.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.generateOutput = void 0;
+    var ts2 = __require("typescript");
+    var package_version_1 = require_package_version();
+    var typescript_1 = require_typescript();
+    function generateOutput(params, options = {}) {
+      const resultOutputParts = [];
+      if (!options.noBanner) {
+        resultOutputParts.push(`// Generated by dts-bundle-generator v${(0, package_version_1.packageVersion)()}`);
+      }
+      if (params.typesReferences.size !== 0) {
+        const header = generateReferenceTypesDirective(Array.from(params.typesReferences));
+        resultOutputParts.push(header);
+      }
+      if (params.imports.size !== 0) {
+        const sortedEntries = Array.from(params.imports.entries()).sort((firstEntry, secondEntry) => {
+          return firstEntry[0].localeCompare(secondEntry[0]);
+        });
+        const importsArray = [];
+        for (const [libraryName, libraryImports] of sortedEntries) {
+          importsArray.push(...generateImports(libraryName, libraryImports));
+        }
+        if (importsArray.length !== 0) {
+          resultOutputParts.push(importsArray.join("\n"));
+        }
+      }
+      const statements = params.statements.map((statement) => getStatementText(statement, Boolean(options.sortStatements), params));
+      if (options.sortStatements) {
+        statements.sort(compareStatementText);
+      }
+      if (statements.length !== 0) {
+        resultOutputParts.push(statementsTextToString(statements));
+      }
+      if (params.wrappedNamespaces.size !== 0) {
+        resultOutputParts.push(Array.from(params.wrappedNamespaces.entries()).map(([namespaceName, exportedNames]) => {
+          return `declare namespace ${namespaceName} {
+	export { ${Array.from(exportedNames.entries()).map(([exportedName, localName]) => renamedExportValue(exportedName, localName)).sort().join(", ")} };
+}`;
+        }).join("\n"));
+      }
+      if (params.renamedExports.size !== 0) {
+        resultOutputParts.push(`export {
+	${Array.from(params.renamedExports.entries()).map(([exportedName, localName]) => renamedExportValue(exportedName, localName)).sort().join(",\n	")},
+};`);
+      }
+      if (options.umdModuleName !== void 0) {
+        resultOutputParts.push(`export as namespace ${options.umdModuleName};`);
+      }
+      resultOutputParts.push(`export {};
+`);
+      return resultOutputParts.join("\n\n");
+    }
+    exports.generateOutput = generateOutput;
+    function statementsTextToString(statements) {
+      const statementsText = statements.map((statement) => statement.text).join("\n");
+      return spacesToTabs(prettifyStatementsText(statementsText));
+    }
+    function renamedExportValue(exportedName, localName) {
+      return exportedName !== localName ? `${localName} as ${exportedName}` : exportedName;
+    }
+    function renamedImportValue(importedName, localName) {
+      return importedName !== localName ? `${importedName} as ${localName}` : importedName;
+    }
+    function prettifyStatementsText(statementsText) {
+      const sourceFile = ts2.createSourceFile("output.d.ts", statementsText, ts2.ScriptTarget.Latest, false, ts2.ScriptKind.TS);
+      const printer = ts2.createPrinter({
+        newLine: ts2.NewLineKind.LineFeed,
+        removeComments: false
+      });
+      return printer.printFile(sourceFile).trim();
+    }
+    function compareStatementText(a, b) {
+      if (a.sortingValue > b.sortingValue) {
+        return 1;
+      } else if (a.sortingValue < b.sortingValue) {
+        return -1;
+      }
+      return 0;
+    }
+    function recreateEntityName(node, helpers) {
+      const resolvedName = helpers.resolveIdentifierName(node);
+      if (resolvedName !== null && resolvedName !== node.getText()) {
+        const identifiers = resolvedName.split(".");
+        let result = ts2.factory.createIdentifier(identifiers[0]);
+        for (let index = 1; index < identifiers.length; index += 1) {
+          result = ts2.factory.createQualifiedName(result, ts2.factory.createIdentifier(identifiers[index]));
+        }
+        return result;
+      }
+      return node;
+    }
+    function getStatementText(statement, includeSortingValue, helpers) {
+      const { shouldHaveExportKeyword, shouldHaveJSDoc } = helpers.getStatementSettings(statement);
+      const needResolveIdentifiers = !ts2.isExportDeclaration(statement) || statement.moduleSpecifier === void 0;
+      const printer = ts2.createPrinter({
+        newLine: ts2.NewLineKind.LineFeed,
+        removeComments: false
+      }, {
+        // eslint-disable-next-line complexity
+        substituteNode: (hint, node) => {
+          if (node.parent === void 0) {
+            return node;
+          }
+          if (needResolveIdentifiers) {
+            if (ts2.isPropertyAccessExpression(node)) {
+              const resolvedName = helpers.resolveIdentifierName(node);
+              if (resolvedName !== null && resolvedName !== node.getText()) {
+                const identifiers = resolvedName.split(".");
+                let result = ts2.factory.createIdentifier(identifiers[0]);
+                for (let index = 1; index < identifiers.length; index += 1) {
+                  result = ts2.factory.createPropertyAccessExpression(result, ts2.factory.createIdentifier(identifiers[index]));
+                }
+                return result;
+              }
+              return node;
+            }
+            if (ts2.isIdentifier(node) || ts2.isQualifiedName(node)) {
+              if (ts2.isIdentifier(node) && (ts2.isQualifiedName(node.parent) || ts2.isPropertyAccessExpression(node.parent))) {
+                return node;
+              }
+              if (ts2.isIdentifier(node) && ts2.isImportTypeNode(node.parent) && node.parent.qualifier === node) {
+                return node;
+              }
+              return recreateEntityName(node, helpers);
+            }
+          }
+          if (ts2.isImportTypeNode(node) && node.qualifier !== void 0 && helpers.needStripImportFromImportTypeNode(node)) {
+            const newQualifier = recreateEntityName(node.qualifier, helpers);
+            if (node.isTypeOf) {
+              return ts2.factory.createTypeQueryNode(newQualifier);
+            }
+            return ts2.factory.createTypeReferenceNode(newQualifier, node.typeArguments);
+          }
+          if (node !== statement) {
+            return node;
+          }
+          const modifiersMap = (0, typescript_1.modifiersToMap)((0, typescript_1.getModifiers)(node));
+          if (ts2.isEnumDeclaration(node) && modifiersMap[ts2.SyntaxKind.ConstKeyword] && helpers.needStripConstFromConstEnum(node)) {
+            modifiersMap[ts2.SyntaxKind.ConstKeyword] = false;
+          }
+          const nodeName = (0, typescript_1.getNodeName)(node);
+          const resolvedStatementName = nodeName !== void 0 ? helpers.resolveIdentifierName(nodeName) || void 0 : void 0;
+          if (modifiersMap[ts2.SyntaxKind.DefaultKeyword]) {
+            modifiersMap[ts2.SyntaxKind.DefaultKeyword] = false;
+            if (ts2.isClassDeclaration(node)) {
+              modifiersMap[ts2.SyntaxKind.DeclareKeyword] = true;
+            }
+          }
+          if (!shouldHaveExportKeyword) {
+            modifiersMap[ts2.SyntaxKind.ExportKeyword] = false;
+          } else {
+            modifiersMap[ts2.SyntaxKind.ExportKeyword] = true;
+          }
+          if (!modifiersMap[ts2.SyntaxKind.ExportKeyword] && (ts2.isClassDeclaration(node) || ts2.isFunctionDeclaration(node) || ts2.isVariableStatement(node) || ts2.isEnumDeclaration(node) || ts2.isModuleDeclaration(node))) {
+            modifiersMap[ts2.SyntaxKind.DeclareKeyword] = true;
+          }
+          return (0, typescript_1.recreateRootLevelNodeWithModifiers)(node, modifiersMap, resolvedStatementName, shouldHaveJSDoc);
+        }
+      });
+      const statementText = printer.printNode(ts2.EmitHint.Unspecified, statement, statement.getSourceFile()).trim();
+      let sortingValue = "";
+      if (includeSortingValue) {
+        const tempSourceFile = ts2.createSourceFile("temp.d.ts", statementText, ts2.ScriptTarget.ESNext);
+        sortingValue = tempSourceFile.getChildren()[0].getText();
+      }
+      return { text: statementText, sortingValue };
+    }
+    function generateImports(libraryName, imports) {
+      const fromEnding = `from '${libraryName}';`;
+      const result = [];
+      if (imports.nsImport !== null) {
+        result.push(`import * as ${imports.nsImport} ${fromEnding}`);
+      }
+      Array.from(imports.requireImports).sort().forEach((importName) => result.push(`import ${importName} = require('${libraryName}');`));
+      Array.from(imports.defaultImports).sort().forEach((importName) => result.push(`import ${importName} ${fromEnding}`));
+      if (imports.namedImports.size !== 0) {
+        result.push(`import { ${Array.from(imports.namedImports.entries()).map(([localName, importedName]) => renamedImportValue(importedName, localName)).sort().join(", ")} } ${fromEnding}`);
+      }
+      if (imports.reExports.size !== 0) {
+        result.push(`export { ${Array.from(imports.reExports.entries()).map(([localName, importedName]) => renamedImportValue(importedName, localName)).sort().join(", ")} } ${fromEnding}`);
+      }
+      return result;
+    }
+    function generateReferenceTypesDirective(libraries) {
+      return libraries.sort().map((library) => {
+        return `/// <reference types="${library}" />`;
+      }).join("\n");
+    }
+    function spacesToTabs(text) {
+      return text.replace(/^(    )+/gm, (substring) => {
+        return "	".repeat(substring.length / 4);
+      });
+    }
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/collisions-resolver.js
+var require_collisions_resolver = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/collisions-resolver.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.CollisionsResolver = void 0;
+    var ts2 = __require("typescript");
+    var typescript_1 = require_typescript();
+    var logger_1 = require_logger();
+    var renamingSupportedSymbols = [
+      ts2.SymbolFlags.Alias,
+      ts2.SymbolFlags.Variable,
+      ts2.SymbolFlags.Class,
+      ts2.SymbolFlags.Enum,
+      ts2.SymbolFlags.Function,
+      ts2.SymbolFlags.Interface,
+      ts2.SymbolFlags.NamespaceModule,
+      ts2.SymbolFlags.TypeAlias,
+      ts2.SymbolFlags.ValueModule
+    ];
+    var CollisionsResolver = class {
+      constructor(typeChecker) {
+        this.collisionsMap = /* @__PURE__ */ new Map();
+        this.generatedNames = /* @__PURE__ */ new Map();
+        this.typeChecker = typeChecker;
+      }
+      /**
+       * Adds (or "registers") a top-level {@link identifier} (which takes a top-level scope name to use).
+       */
+      addTopLevelIdentifier(identifier) {
+        const symbol = (0, typescript_1.getDeclarationNameSymbol)(identifier, this.typeChecker);
+        if (symbol === null) {
+          throw new Error(`Something went wrong - cannot find a symbol for top-level identifier ${identifier.getText()} (from ${identifier.parent.parent.getText()})`);
+        }
+        const newLocalName = this.registerSymbol(symbol, identifier.getText());
+        if (newLocalName === null) {
+          throw new Error(`Something went wrong - a symbol ${symbol.name} for top-level identifier ${identifier.getText()} cannot be renamed`);
+        }
+        return newLocalName;
+      }
+      /**
+       * Returns a set of all already registered names for a given {@link symbol}.
+       */
+      namesForSymbol(symbol) {
+        return this.generatedNames.get((0, typescript_1.getActualSymbol)(symbol, this.typeChecker)) || /* @__PURE__ */ new Set();
+      }
+      /**
+       * Resolves given {@link referencedIdentifier} to a name.
+       * It assumes that a symbol for this identifier has been registered before by calling {@link addTopLevelIdentifier} method.
+       * Otherwise it will return `null`.
+       *
+       * Note that a returned value might be of a different type of the identifier (e.g. {@link ts.QualifiedName} for a given {@link ts.Identifier})
+       */
+      resolveReferencedIdentifier(referencedIdentifier) {
+        const identifierSymbol = (0, typescript_1.getDeclarationNameSymbol)(referencedIdentifier, this.typeChecker);
+        if (identifierSymbol === null) {
+          return null;
+        }
+        const symbolScopePath = this.getSymbolScope(identifierSymbol);
+        const currentIdentifierScope = this.getNodeScope(referencedIdentifier);
+        if (symbolScopePath.length > 0 && currentIdentifierScope.length > 0 && symbolScopePath[0] === currentIdentifierScope[0]) {
+          return referencedIdentifier.getText();
+        }
+        const topLevelIdentifierSymbol = symbolScopePath.length === 0 ? identifierSymbol : symbolScopePath[0];
+        const namesForTopLevelSymbol = this.namesForSymbol(topLevelIdentifierSymbol);
+        if (namesForTopLevelSymbol.size === 0) {
+          return null;
+        }
+        let topLevelName = symbolScopePath.length === 0 ? referencedIdentifier.getText() : topLevelIdentifierSymbol.getName();
+        if (!namesForTopLevelSymbol.has(topLevelName)) {
+          const topLevelNamesArray = Array.from(namesForTopLevelSymbol);
+          let suitableTopLevelName = topLevelNamesArray[0];
+          for (const name of topLevelNamesArray) {
+            if (name.startsWith(`${topLevelName}$`)) {
+              suitableTopLevelName = name;
+              break;
+            }
+          }
+          topLevelName = suitableTopLevelName;
+        }
+        const newIdentifierParts = [
+          ...symbolScopePath.map((symbol) => symbol.getName()),
+          referencedIdentifier.getText()
+        ];
+        newIdentifierParts[0] = topLevelName;
+        return newIdentifierParts.join(".");
+      }
+      /**
+       * Similar to {@link resolveReferencedIdentifier}, but works with qualified names (Ns.Ns1.Interface).
+       * The main point of this resolver is that it might change the first part of the qualifier only (as it drives uniqueness of a name).
+       */
+      resolveReferencedQualifiedName(referencedIdentifier) {
+        let topLevelIdentifier = referencedIdentifier;
+        if (ts2.isQualifiedName(topLevelIdentifier) || ts2.isPropertyAccessExpression(topLevelIdentifier)) {
+          let leftmostIdentifier = ts2.isQualifiedName(topLevelIdentifier) ? topLevelIdentifier.left : topLevelIdentifier.expression;
+          while (ts2.isQualifiedName(leftmostIdentifier) || ts2.isPropertyAccessExpression(leftmostIdentifier)) {
+            leftmostIdentifier = ts2.isQualifiedName(leftmostIdentifier) ? leftmostIdentifier.left : leftmostIdentifier.expression;
+          }
+          topLevelIdentifier = leftmostIdentifier;
+        }
+        const topLevelName = this.resolveReferencedIdentifier(topLevelIdentifier);
+        if (topLevelName === null) {
+          const identifierSymbol = (0, typescript_1.getDeclarationNameSymbol)(referencedIdentifier, this.typeChecker);
+          if (identifierSymbol === null) {
+            return null;
+          }
+          const namesForSymbol = this.namesForSymbol(identifierSymbol);
+          if (namesForSymbol.size !== 0) {
+            return Array.from(namesForSymbol)[0];
+          }
+          return null;
+        }
+        const identifierParts = referencedIdentifier.getText().split(".");
+        identifierParts[0] = topLevelName;
+        return identifierParts.join(".");
+      }
+      getSymbolScope(identifierSymbol) {
+        const identifierDeclarations = (0, typescript_1.getDeclarationsForSymbol)(identifierSymbol);
+        if (identifierDeclarations.length === 0) {
+          return [];
+        }
+        return this.getNodeScope(identifierDeclarations[0]);
+      }
+      /**
+       * Returns a node's scope where it is located in terms of namespaces/modules.
+       * E.g. A scope for `Opt` in `declare module foo { type Opt = number; }` is `[Symbol(foo)]`
+       */
+      getNodeScope(node) {
+        const scopeIdentifiersPath = [];
+        let currentNode = (0, typescript_1.getClosestModuleLikeNode)(node);
+        while (ts2.isModuleDeclaration(currentNode) && ts2.isIdentifier(currentNode.name)) {
+          const nameSymbol = (0, typescript_1.getDeclarationNameSymbol)(currentNode.name, this.typeChecker);
+          if (nameSymbol === null) {
+            throw new Error(`Cannot find symbol for identifier '${currentNode.name.getText()}'`);
+          }
+          scopeIdentifiersPath.push(nameSymbol);
+          currentNode = (0, typescript_1.getClosestModuleLikeNode)(currentNode.parent);
+        }
+        return scopeIdentifiersPath.reverse();
+      }
+      registerSymbol(identifierSymbol, preferredName) {
+        if (!renamingSupportedSymbols.some((flag) => identifierSymbol.flags & flag)) {
+          (0, logger_1.verboseLog)(`Symbol ${identifierSymbol.name} cannot be renamed because its flag (${identifierSymbol.flags}) isn't supported`);
+          return null;
+        }
+        if (identifierSymbol.flags & ts2.SymbolFlags.NamespaceModule && identifierSymbol.escapedName === ts2.InternalSymbolName.Global) {
+          return null;
+        }
+        let symbolName = preferredName;
+        if (symbolName === "default") {
+          symbolName = "_default";
+        }
+        const collisionsKey = symbolName;
+        let collisionSymbols = this.collisionsMap.get(collisionsKey);
+        if (collisionSymbols === void 0) {
+          collisionSymbols = /* @__PURE__ */ new Map();
+          this.collisionsMap.set(collisionsKey, collisionSymbols);
+        }
+        const storedSymbolName = collisionSymbols.get(identifierSymbol);
+        if (storedSymbolName !== void 0) {
+          return storedSymbolName;
+        }
+        let nameIndex = collisionSymbols.size;
+        let newName = collisionSymbols.size === 0 ? symbolName : `${symbolName}$${nameIndex}`;
+        let resolvedGlobalSymbol = (0, typescript_1.resolveGlobalName)(this.typeChecker, newName);
+        while (resolvedGlobalSymbol !== void 0 && resolvedGlobalSymbol !== identifierSymbol) {
+          nameIndex += 1;
+          newName = `${symbolName}$${nameIndex}`;
+          resolvedGlobalSymbol = (0, typescript_1.resolveGlobalName)(this.typeChecker, newName);
+        }
+        collisionSymbols.set(identifierSymbol, newName);
+        let symbolNames = this.generatedNames.get(identifierSymbol);
+        if (symbolNames === void 0) {
+          symbolNames = /* @__PURE__ */ new Set();
+          this.generatedNames.set(identifierSymbol, symbolNames);
+        }
+        symbolNames.add(newName);
+        return newName;
+      }
+    };
+    exports.CollisionsResolver = CollisionsResolver;
+  }
+});
+
+// ../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/bundle-generator.js
+var require_bundle_generator = __commonJS({
+  "../node_modules/.bun/dts-bundle-generator@9.5.1/node_modules/dts-bundle-generator/dist/bundle-generator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.generateDtsBundle = void 0;
+    var ts2 = __require("typescript");
+    var compile_dts_1 = require_compile_dts();
+    var types_usage_evaluator_1 = require_types_usage_evaluator();
+    var typescript_1 = require_typescript();
+    var module_info_1 = require_module_info();
+    var generate_output_1 = require_generate_output();
+    var logger_1 = require_logger();
+    var collisions_resolver_1 = require_collisions_resolver();
+    function generateDtsBundle2(entries, options = {}) {
+      (0, logger_1.normalLog)("Compiling input files...");
+      const { program, rootFilesRemapping } = (0, compile_dts_1.compileDts)(entries.map((entry) => entry.filePath), options.preferredConfigPath, options.followSymlinks);
+      const typeChecker = program.getTypeChecker();
+      const typeRoots = ts2.getEffectiveTypeRoots(program.getCompilerOptions(), {});
+      const sourceFiles = program.getSourceFiles().filter((file) => {
+        return !program.isSourceFileDefaultLibrary(file);
+      });
+      const typesUsageEvaluator = new types_usage_evaluator_1.TypesUsageEvaluator(sourceFiles, typeChecker);
+      return entries.map((entryConfig) => {
+        (0, logger_1.normalLog)(`Processing ${entryConfig.filePath}`);
+        const newRootFilePath = rootFilesRemapping.get(entryConfig.filePath);
+        if (newRootFilePath === void 0) {
+          throw new Error(`Cannot remap root source file ${entryConfig.filePath}`);
+        }
+        const rootSourceFile = (0, typescript_1.getRootSourceFile)(program, newRootFilePath);
+        const rootSourceFileSymbol = typeChecker.getSymbolAtLocation(rootSourceFile);
+        if (rootSourceFileSymbol === void 0) {
+          throw new Error(`Symbol for root source file ${newRootFilePath} not found`);
+        }
+        const librariesOptions = entryConfig.libraries || {};
+        const criteria = {
+          allowedTypesLibraries: librariesOptions.allowedTypesLibraries,
+          importedLibraries: librariesOptions.importedLibraries,
+          inlinedLibraries: librariesOptions.inlinedLibraries || [],
+          typeRoots
+        };
+        const rootFileExports = (0, typescript_1.getExportsForSourceFile)(typeChecker, rootSourceFileSymbol);
+        const rootFileExportSymbols = rootFileExports.map((exp) => exp.symbol);
+        const collectionResult = {
+          typesReferences: /* @__PURE__ */ new Set(),
+          imports: /* @__PURE__ */ new Map(),
+          statements: [],
+          renamedExports: /* @__PURE__ */ new Map(),
+          wrappedNamespaces: /* @__PURE__ */ new Map()
+        };
+        const outputOptions = entryConfig.output || {};
+        const inlineDeclareGlobals = Boolean(outputOptions.inlineDeclareGlobals);
+        const inlineDeclareExternals = Boolean(outputOptions.inlineDeclareExternals);
+        const collisionsResolver = new collisions_resolver_1.CollisionsResolver(typeChecker);
+        function updateResultForAnyModule(statements, currentModule) {
+          const visitedModules = /* @__PURE__ */ new Set();
+          function updateResultForExternalExport(exportAssignment) {
+            for (const declaration of (0, typescript_1.getDeclarationsForExportedValues)(exportAssignment, typeChecker)) {
+              if (ts2.isVariableDeclaration(declaration)) {
+                continue;
+              }
+              let exportedDeclarations = [];
+              if (ts2.isExportDeclaration(exportAssignment) && ts2.isSourceFile(declaration)) {
+                const referencedModule = (0, module_info_1.getReferencedModuleInfo)(exportAssignment, criteria, typeChecker);
+                if (referencedModule !== null) {
+                  if (visitedModules.has(referencedModule.fileName)) {
+                    continue;
+                  }
+                  visitedModules.add(referencedModule.fileName);
+                }
+                exportedDeclarations = declaration.statements;
+              } else if (ts2.isModuleDeclaration(declaration)) {
+                if (declaration.body !== void 0 && ts2.isModuleBlock(declaration.body)) {
+                  const referencedModule = (0, module_info_1.getReferencedModuleInfo)(declaration, criteria, typeChecker);
+                  if (referencedModule !== null) {
+                    if (visitedModules.has(referencedModule.fileName)) {
+                      continue;
+                    }
+                    visitedModules.add(referencedModule.fileName);
+                  }
+                  exportedDeclarations = declaration.body.statements;
+                }
+              } else {
+                exportedDeclarations = [declaration];
+              }
+              updateResultImpl(exportedDeclarations);
+            }
+          }
+          function updateResultImpl(statementsToProcess) {
+            for (const statement of statementsToProcess) {
+              if (statement.kind === ts2.SyntaxKind.ImportDeclaration || statement.kind === ts2.SyntaxKind.ImportEqualsDeclaration) {
+                continue;
+              }
+              if ((0, typescript_1.isDeclareModule)(statement)) {
+                updateResultForModuleDeclaration(statement, currentModule);
+                if (ts2.isStringLiteral(statement.name)) {
+                  continue;
+                }
+              }
+              if (currentModule.type === 3) {
+                continue;
+              }
+              if ((0, typescript_1.isDeclareGlobalStatement)(statement) && inlineDeclareGlobals && currentModule.type === 0) {
+                collectionResult.statements.push(statement);
+                continue;
+              }
+              if (ts2.isExportDeclaration(statement)) {
+                if (currentModule.type === 0) {
+                  continue;
+                }
+                if (statement.exportClause === void 0) {
+                  updateResultForExternalExport(statement);
+                  continue;
+                }
+                if (ts2.isNamedExports(statement.exportClause) && currentModule.type === 1) {
+                  updateImportsForStatement(statement);
+                  continue;
+                }
+              }
+              if (ts2.isExportAssignment(statement) && statement.isExportEquals && currentModule.type !== 0) {
+                updateResultForExternalExport(statement);
+                continue;
+              }
+              if (!isNodeUsed(statement)) {
+                continue;
+              }
+              switch (currentModule.type) {
+                case 2:
+                  forEachNodeThatShouldBeImported(statement, () => addTypesReference(currentModule.typesLibraryName));
+                  break;
+                case 1:
+                  updateImportsForStatement(statement);
+                  break;
+                case 0:
+                  if (ts2.isVariableStatement(statement)) {
+                    for (const variableDeclaration of statement.declarationList.declarations) {
+                      if (ts2.isIdentifier(variableDeclaration.name)) {
+                        collisionsResolver.addTopLevelIdentifier(variableDeclaration.name);
+                        continue;
+                      }
+                      for (const element of variableDeclaration.name.elements) {
+                        if (!ts2.isOmittedExpression(element) && ts2.isIdentifier(element.name)) {
+                          collisionsResolver.addTopLevelIdentifier(element.name);
+                        }
+                      }
+                    }
+                  } else if ((0, typescript_1.isNodeNamedDeclaration)(statement)) {
+                    const statementName = (0, typescript_1.getNodeName)(statement);
+                    if (statementName !== void 0) {
+                      collisionsResolver.addTopLevelIdentifier(statementName);
+                    }
+                  }
+                  collectionResult.statements.push(statement);
+                  break;
+              }
+            }
+          }
+          updateResultImpl(statements);
+        }
+        function isReferencedModuleImportable(statement) {
+          return (0, module_info_1.getReferencedModuleInfo)(statement, criteria, typeChecker)?.type === 1;
+        }
+        function handleExportDeclarationFromRootModule(exportDeclaration) {
+          function handleExportStarStatement(exportStarStatement, visitedSymbols = /* @__PURE__ */ new Set()) {
+            if (exportStarStatement.moduleSpecifier === void 0 || exportStarStatement.exportClause !== void 0) {
+              throw new Error(`Invalid export-star declaration statement provided, ${exportStarStatement.getText()}`);
+            }
+            const importModuleSpecifier = (0, typescript_1.getImportModuleName)(exportStarStatement);
+            if (importModuleSpecifier === null) {
+              return;
+            }
+            const referencedModuleInfo = (0, module_info_1.getReferencedModuleInfo)(exportStarStatement, criteria, typeChecker);
+            if (referencedModuleInfo === null) {
+              return;
+            }
+            switch (referencedModuleInfo.type) {
+              case 0: {
+                const referencedModuleSymbol = (0, typescript_1.getNodeOwnSymbol)(exportStarStatement.moduleSpecifier, typeChecker);
+                const referencedSourceFileExportStarSymbol = referencedModuleSymbol.exports?.get(ts2.InternalSymbolName.ExportStar);
+                if (referencedSourceFileExportStarSymbol !== void 0) {
+                  if (visitedSymbols.has(referencedSourceFileExportStarSymbol)) {
+                    return;
+                  }
+                  visitedSymbols.add(referencedSourceFileExportStarSymbol);
+                  for (const exportDecl of (0, typescript_1.getSymbolExportStarDeclarations)(referencedSourceFileExportStarSymbol)) {
+                    handleExportStarStatement(exportDecl, visitedSymbols);
+                  }
+                }
+                break;
+              }
+              case 1: {
+                collectionResult.statements.push(exportStarStatement);
+                break;
+              }
+            }
+          }
+          function findExportingExportStarExportFromImportableModule(referencedModuleSymbol, nodeSymbol) {
+            function findResultRecursively(referencedModuleSym, exportedNodeSym, visitedSymbols) {
+              if (visitedSymbols.has(referencedModuleSym)) {
+                return null;
+              }
+              visitedSymbols.add(referencedModuleSym);
+              const exportStarExport = referencedModuleSym.exports?.get(ts2.InternalSymbolName.ExportStar);
+              if (exportStarExport === void 0) {
+                return null;
+              }
+              for (const exportStarDeclaration of (0, typescript_1.getDeclarationsForSymbol)(exportStarExport).filter(ts2.isExportDeclaration)) {
+                if (exportStarDeclaration.moduleSpecifier === void 0) {
+                  continue;
+                }
+                const exportStarModuleSymbol = (0, typescript_1.getNodeOwnSymbol)(exportStarDeclaration.moduleSpecifier, typeChecker);
+                if (exportStarModuleSymbol.exports === void 0) {
+                  continue;
+                }
+                if (isReferencedModuleImportable(exportStarDeclaration)) {
+                  const referencedModuleExports = typeChecker.getExportsOfModule(exportStarModuleSymbol);
+                  const exportedNodeSymbol = referencedModuleExports.find((exp) => (0, typescript_1.getActualSymbol)(exp, typeChecker) === nodeSymbol);
+                  if (exportedNodeSymbol !== void 0) {
+                    return { exportStarDeclaration, exportedNodeSymbol };
+                  }
+                  continue;
+                }
+                const result = findResultRecursively(exportStarModuleSymbol, exportedNodeSym, visitedSymbols);
+                if (result !== null) {
+                  return result;
+                }
+              }
+              return null;
+            }
+            if (referencedModuleSymbol.exports === void 0) {
+              throw new Error(`No exports found for "${referencedModuleSymbol.getName()}" symbol`);
+            }
+            const hasExplicitExportOfSymbol = Array.from(referencedModuleSymbol.exports.values()).some((exp) => {
+              if (exp.escapedName === ts2.InternalSymbolName.ExportStar) {
+                return false;
+              }
+              return (0, typescript_1.getActualSymbol)(exp, typeChecker) === nodeSymbol;
+            });
+            if (hasExplicitExportOfSymbol) {
+              return null;
+            }
+            return findResultRecursively(referencedModuleSymbol, nodeSymbol, /* @__PURE__ */ new Set());
+          }
+          if (exportDeclaration.exportClause === void 0) {
+            handleExportStarStatement(exportDeclaration);
+            return;
+          }
+          if (exportDeclaration.exportClause !== void 0 && ts2.isNamedExports(exportDeclaration.exportClause)) {
+            if (exportDeclaration.moduleSpecifier === void 0) {
+              for (const exportElement of exportDeclaration.exportClause.elements) {
+                const exportElementSymbol = (0, typescript_1.getImportExportReferencedSymbol)(exportElement, typeChecker);
+                const namespaceImportFromImportableModule = (0, typescript_1.getDeclarationsForSymbol)(exportElementSymbol).find((importDecl) => {
+                  return ts2.isNamespaceImport(importDecl) && isReferencedModuleImportable(importDecl.parent.parent);
+                });
+                if (namespaceImportFromImportableModule !== void 0) {
+                  const importModuleSpecifier = (0, typescript_1.getImportModuleName)(namespaceImportFromImportableModule.parent.parent);
+                  if (importModuleSpecifier === null) {
+                    throw new Error(`Cannot get import module name from '${namespaceImportFromImportableModule.parent.parent.getText()}'`);
+                  }
+                  addNsImport(getImportItem(importModuleSpecifier), namespaceImportFromImportableModule.name);
+                }
+              }
+              return;
+            }
+            if (exportDeclaration.moduleSpecifier !== void 0) {
+              const referencedModuleSymbol = (0, typescript_1.getNodeOwnSymbol)(exportDeclaration.moduleSpecifier, typeChecker);
+              for (const exportElement of exportDeclaration.exportClause.elements) {
+                const exportedNodeSymbol = (0, typescript_1.getActualSymbol)((0, typescript_1.getImportExportReferencedSymbol)(exportElement, typeChecker), typeChecker);
+                const exportingExportStarResult = findExportingExportStarExportFromImportableModule(referencedModuleSymbol, exportedNodeSymbol);
+                if (exportingExportStarResult === null) {
+                  continue;
+                }
+                const importModuleSpecifier = (0, typescript_1.getImportModuleName)(exportingExportStarResult.exportStarDeclaration);
+                if (importModuleSpecifier === null) {
+                  throw new Error(`Cannot get import module name from '${exportingExportStarResult.exportStarDeclaration.getText()}'`);
+                }
+                addReExport(getImportItem(importModuleSpecifier), exportingExportStarResult.exportedNodeSymbol.getName(), exportElement.name.text);
+              }
+              return;
+            }
+          }
+        }
+        function updateResultForRootModule(statements, currentModule) {
+          updateResultForAnyModule(statements, currentModule);
+          for (const statement of statements) {
+            if (ts2.isExportDeclaration(statement)) {
+              handleExportDeclarationFromRootModule(statement);
+              continue;
+            }
+            if (ts2.isExportAssignment(statement)) {
+              if (statement.isExportEquals || !ts2.isIdentifier(statement.expression)) {
+                collectionResult.statements.push(statement);
+              }
+              continue;
+            }
+          }
+        }
+        function updateResultForModuleDeclaration(moduleDecl, currentModule) {
+          if (moduleDecl.body === void 0 || !ts2.isModuleBlock(moduleDecl.body)) {
+            return;
+          }
+          const referencedModuleInfo = (0, module_info_1.getModuleLikeModuleInfo)(moduleDecl, criteria, typeChecker);
+          if (referencedModuleInfo === null) {
+            return;
+          }
+          if (!currentModule.isExternal && referencedModuleInfo.isExternal) {
+            if (inlineDeclareExternals) {
+              collectionResult.statements.push(moduleDecl);
+            }
+            return;
+          }
+          updateResultForAnyModule(moduleDecl.body.statements, referencedModuleInfo);
+        }
+        function addTypesReference(library) {
+          if (!collectionResult.typesReferences.has(library)) {
+            (0, logger_1.normalLog)(`Library "${library}" will be added via reference directive`);
+            collectionResult.typesReferences.add(library);
+          }
+        }
+        function forEachNodeThatShouldBeImported(statement, callback) {
+          const statementsToImport = ts2.isVariableStatement(statement) ? statement.declarationList.declarations : ts2.isExportDeclaration(statement) && statement.exportClause !== void 0 ? ts2.isNamespaceExport(statement.exportClause) ? [statement.exportClause] : statement.exportClause.elements : [statement];
+          for (const statementToImport of statementsToImport) {
+            if (shouldNodeBeImported(statementToImport)) {
+              callback(statementToImport);
+            }
+          }
+        }
+        function updateImportsForStatement(statement) {
+          forEachNodeThatShouldBeImported(statement, (statementToImport) => {
+            addImport(statementToImport);
+            const sourceFile = statementToImport.getSourceFile();
+            const moduleInfo = (0, module_info_1.getFileModuleInfo)(sourceFile.fileName, criteria);
+            if (moduleInfo.type === 2) {
+              addTypesReference(moduleInfo.typesLibraryName);
+            }
+          });
+        }
+        function getDeclarationUsagesSourceFiles(declaration) {
+          return new Set(getExportedSymbolsUsingStatement(declaration).map((symbol) => (0, typescript_1.getDeclarationsForSymbol)(symbol)).reduce((acc, val) => acc.concat(val), []).map(typescript_1.getClosestModuleLikeNode));
+        }
+        function getImportItem(importModuleSpecifier) {
+          let importItem = collectionResult.imports.get(importModuleSpecifier);
+          if (importItem === void 0) {
+            importItem = {
+              defaultImports: /* @__PURE__ */ new Set(),
+              namedImports: /* @__PURE__ */ new Map(),
+              nsImport: null,
+              requireImports: /* @__PURE__ */ new Set(),
+              reExports: /* @__PURE__ */ new Map()
+            };
+            collectionResult.imports.set(importModuleSpecifier, importItem);
+          }
+          return importItem;
+        }
+        function addRequireImport(importItem, preferredLocalName) {
+          importItem.requireImports.add(collisionsResolver.addTopLevelIdentifier(preferredLocalName));
+        }
+        function addNamedImport(importItem, preferredLocalName, importedIdentifier) {
+          const newLocalName = collisionsResolver.addTopLevelIdentifier(preferredLocalName);
+          const importedName = importedIdentifier.text;
+          importItem.namedImports.set(newLocalName, importedName);
+        }
+        function addReExport(importItem, moduleExportedName, reExportedName) {
+          importItem.reExports.set(reExportedName, moduleExportedName);
+        }
+        function addNsImport(importItem, preferredLocalName) {
+          if (importItem.nsImport === null) {
+            importItem.nsImport = collisionsResolver.addTopLevelIdentifier(preferredLocalName);
+          }
+        }
+        function addDefaultImport(importItem, preferredLocalName) {
+          importItem.defaultImports.add(collisionsResolver.addTopLevelIdentifier(preferredLocalName));
+        }
+        function addImport(statement) {
+          forEachImportOfStatement(statement, (imp, referencedModuleInfo, importModuleSpecifier) => {
+            if (referencedModuleInfo.type !== 1) {
+              return;
+            }
+            const importItem = getImportItem(importModuleSpecifier);
+            if (ts2.isImportEqualsDeclaration(imp)) {
+              addRequireImport(importItem, imp.name);
+              return;
+            }
+            if (ts2.isExportSpecifier(imp)) {
+              addNamedImport(importItem, imp.name, imp.propertyName || imp.name);
+              return;
+            }
+            if (ts2.isNamespaceExport(imp)) {
+              addNsImport(importItem, imp.name);
+              return;
+            }
+            if (ts2.isImportClause(imp) && imp.name !== void 0) {
+              addDefaultImport(importItem, imp.name);
+              return;
+            }
+            if (ts2.isImportSpecifier(imp)) {
+              addNamedImport(importItem, imp.name, imp.propertyName || imp.name);
+              return;
+            }
+            if (ts2.isNamespaceImport(imp)) {
+              addNsImport(importItem, imp.name);
+              return;
+            }
+          });
+        }
+        function forEachImportOfStatement(statement, callback) {
+          if (!ts2.isSourceFile(statement) && statement.name === void 0) {
+            throw new Error(`Import/usage unnamed declaration: ${statement.getText()}`);
+          }
+          getDeclarationUsagesSourceFiles(statement).forEach((sourceFile) => {
+            if ((0, module_info_1.getModuleLikeModuleInfo)(sourceFile, criteria, typeChecker).type !== 0) {
+              return;
+            }
+            const sourceFileStatements = ts2.isSourceFile(sourceFile) ? sourceFile.statements : sourceFile.body !== void 0 && ts2.isModuleBlock(sourceFile.body) ? sourceFile.body.statements : [];
+            sourceFileStatements.forEach((st) => {
+              if (!ts2.isImportEqualsDeclaration(st) && !ts2.isImportDeclaration(st) && !ts2.isExportDeclaration(st)) {
+                return;
+              }
+              const importModuleSpecifier = (0, typescript_1.getImportModuleName)(st);
+              if (importModuleSpecifier === null) {
+                return;
+              }
+              const referencedModuleInfo = (0, module_info_1.getReferencedModuleInfo)(st, criteria, typeChecker);
+              if (referencedModuleInfo === null) {
+                return;
+              }
+              if (ts2.isImportEqualsDeclaration(st)) {
+                if (areDeclarationSame(statement, st)) {
+                  callback(st, referencedModuleInfo, importModuleSpecifier);
+                }
+                return;
+              }
+              if (ts2.isExportDeclaration(st) && st.exportClause !== void 0) {
+                if (ts2.isNamedExports(st.exportClause)) {
+                  st.exportClause.elements.filter(areDeclarationSame.bind(null, statement)).forEach((specifier) => {
+                    callback(specifier, referencedModuleInfo, importModuleSpecifier);
+                  });
+                } else {
+                  if (isNodeUsed(st.exportClause)) {
+                    callback(st.exportClause, referencedModuleInfo, importModuleSpecifier);
+                  }
+                }
+              } else if (ts2.isImportDeclaration(st) && st.importClause !== void 0) {
+                if (st.importClause.name !== void 0 && areDeclarationSame(statement, st.importClause)) {
+                  callback(st.importClause, referencedModuleInfo, importModuleSpecifier);
+                }
+                if (st.importClause.namedBindings !== void 0) {
+                  if (ts2.isNamedImports(st.importClause.namedBindings)) {
+                    st.importClause.namedBindings.elements.filter(areDeclarationSame.bind(null, statement)).forEach((specifier) => {
+                      callback(specifier, referencedModuleInfo, importModuleSpecifier);
+                    });
+                  } else {
+                    if (isNodeUsed(st.importClause)) {
+                      callback(st.importClause.namedBindings, referencedModuleInfo, importModuleSpecifier);
+                    }
+                  }
+                }
+              }
+            });
+          });
+        }
+        function getInlinedSymbolsUsingSymbol(symbol, predicate) {
+          return Array.from(typesUsageEvaluator.getSymbolsUsingSymbol(symbol) ?? []).filter((usedInSymbol) => {
+            if (!predicate(usedInSymbol)) {
+              return false;
+            }
+            return (0, typescript_1.getDeclarationsForSymbol)(usedInSymbol).some((decl) => {
+              const closestModuleLike = (0, typescript_1.getClosestSourceFileLikeNode)(decl);
+              const moduleInfo = (0, module_info_1.getModuleLikeModuleInfo)(closestModuleLike, criteria, typeChecker);
+              return moduleInfo.type === 0;
+            });
+          });
+        }
+        function isSymbolUsedByInlinedSymbols(symbol, predicate, visitedSymbols = /* @__PURE__ */ new Set()) {
+          if (visitedSymbols.has(symbol)) {
+            return false;
+          }
+          visitedSymbols.add(symbol);
+          return Array.from(typesUsageEvaluator.getSymbolsUsingSymbol(symbol) ?? []).some((usedInSymbol) => {
+            if (!predicate(usedInSymbol)) {
+              return isSymbolUsedByInlinedSymbols(usedInSymbol, predicate, visitedSymbols);
+            }
+            const usedByThisSymbol = (0, typescript_1.getDeclarationsForSymbol)(usedInSymbol).some((decl) => {
+              const closestModuleLike = (0, typescript_1.getClosestSourceFileLikeNode)(decl);
+              const moduleInfo = (0, module_info_1.getModuleLikeModuleInfo)(closestModuleLike, criteria, typeChecker);
+              return moduleInfo.type === 0;
+            });
+            if (usedByThisSymbol) {
+              return true;
+            }
+            return isSymbolUsedByInlinedSymbols(usedInSymbol, predicate, visitedSymbols);
+          });
+        }
+        function isSymbolUsedByRootFileExports(symbol) {
+          return rootFileExportSymbols.some((rootSymbol) => typesUsageEvaluator.isSymbolUsedBySymbol(symbol, rootSymbol));
+        }
+        function isSymbolForGlobalDeclaration(symbol) {
+          return symbol.escapedName === ts2.InternalSymbolName.Global;
+        }
+        function isSymbolForDeclareModuleDeclaration(symbol) {
+          return (0, typescript_1.getDeclarationsForSymbol)(symbol).some(typescript_1.isDeclareModule);
+        }
+        function isNodeUsed(node) {
+          if ((0, typescript_1.isNodeNamedDeclaration)(node) || ts2.isSourceFile(node)) {
+            const nodeSymbol = (0, typescript_1.getNodeSymbol)(node, typeChecker);
+            if (nodeSymbol === null) {
+              return false;
+            }
+            const nodeUsedByDirectExports = isSymbolUsedByRootFileExports(nodeSymbol);
+            if (nodeUsedByDirectExports) {
+              return true;
+            }
+            if (inlineDeclareGlobals && isSymbolUsedByInlinedSymbols(nodeSymbol, isSymbolForGlobalDeclaration)) {
+              return true;
+            }
+            if (inlineDeclareExternals && isSymbolUsedByInlinedSymbols(nodeSymbol, isSymbolForDeclareModuleDeclaration)) {
+              return true;
+            }
+            return false;
+          }
+          if (ts2.isVariableStatement(node)) {
+            return node.declarationList.declarations.some((declaration) => {
+              if (ts2.isObjectBindingPattern(declaration.name) || ts2.isArrayBindingPattern(declaration.name)) {
+                return declaration.name.elements.some(isNodeUsed);
+              }
+              return isNodeUsed(declaration);
+            });
+          }
+          if (ts2.isExportDeclaration(node) && node.exportClause !== void 0 && ts2.isNamespaceExport(node.exportClause)) {
+            return isNodeUsed(node.exportClause);
+          }
+          if (ts2.isImportClause(node) && node.namedBindings !== void 0) {
+            return isNodeUsed(node.namedBindings);
+          }
+          return false;
+        }
+        function shouldNodeBeImported(node) {
+          const nodeSymbol = (0, typescript_1.getNodeSymbol)(node, typeChecker);
+          if (nodeSymbol === null) {
+            return false;
+          }
+          return shouldSymbolBeImported(nodeSymbol);
+        }
+        function shouldSymbolBeImported(nodeSymbol) {
+          const isSymbolDeclaredInDefaultLibrary = (0, typescript_1.getDeclarationsForSymbol)(nodeSymbol).some((declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile()));
+          if (isSymbolDeclaredInDefaultLibrary) {
+            return false;
+          }
+          const symbolsDeclarations = (0, typescript_1.getDeclarationsForSymbol)(nodeSymbol);
+          const shouldSymbolBeInlined = symbolsDeclarations.every(
+            (decl) => (0, module_info_1.getModuleLikeModuleInfo)((0, typescript_1.getClosestSourceFileLikeNode)(decl), criteria, typeChecker).type === 0
+            /* ModuleType.ShouldBeInlined */
+          );
+          if (shouldSymbolBeInlined) {
+            return false;
+          }
+          return getExportedSymbolsUsingSymbol(nodeSymbol).length !== 0;
+        }
+        function getExportedSymbolsUsingStatement(node) {
+          const nodeSymbol = (0, typescript_1.getNodeSymbol)(node, typeChecker);
+          if (nodeSymbol === null) {
+            return [];
+          }
+          return getExportedSymbolsUsingSymbol(nodeSymbol);
+        }
+        function getExportedSymbolsUsingSymbol(nodeSymbol) {
+          const symbolsUsingNode = typesUsageEvaluator.getSymbolsUsingSymbol(nodeSymbol);
+          if (symbolsUsingNode === null) {
+            throw new Error(`Something went wrong - getSymbolsUsingSymbol returned null but expected to be a set of symbols (symbol=${nodeSymbol.name})`);
+          }
+          return [
+            ...rootFileExportSymbols.includes(nodeSymbol) ? [nodeSymbol] : [],
+            // symbols which are used in types directly
+            ...getInlinedSymbolsUsingSymbol(nodeSymbol, isSymbolUsedByRootFileExports),
+            // symbols which are used in global types i.e. in `declare global`s
+            ...inlineDeclareGlobals ? getInlinedSymbolsUsingSymbol(nodeSymbol, isSymbolForGlobalDeclaration) : [],
+            // symbols which are used in "declare module" types
+            ...inlineDeclareExternals ? getInlinedSymbolsUsingSymbol(nodeSymbol, isSymbolForDeclareModuleDeclaration) : []
+          ];
+        }
+        function areDeclarationSame(left, right) {
+          const leftSymbols = (0, typescript_1.splitTransientSymbol)((0, typescript_1.getNodeSymbol)(left, typeChecker), typeChecker);
+          const rightSymbols = (0, typescript_1.splitTransientSymbol)((0, typescript_1.getNodeSymbol)(right, typeChecker), typeChecker);
+          for (const leftSymbol of leftSymbols) {
+            if (rightSymbols.has(leftSymbol)) {
+              return true;
+            }
+          }
+          return false;
+        }
+        function createNamespaceForExports(exports2, namespaceSymbol) {
+          function addSymbolToNamespaceExports(namespaceExports2, symbol) {
+            if (!typesUsageEvaluator.isSymbolUsedBySymbol(symbol, namespaceSymbol)) {
+              return;
+            }
+            const symbolKnownNames = collisionsResolver.namesForSymbol(symbol);
+            if (symbolKnownNames.size === 0) {
+              throw new Error(`Cannot get local names for symbol '${symbol.getName()}' while generating namespaced export`);
+            }
+            namespaceExports2.set(symbol.getName(), Array.from(symbolKnownNames)[0]);
+          }
+          function handleNamespacedImportOrExport(namespacedImportOrExport, namespaceExports2, symbol) {
+            if (namespacedImportOrExport.moduleSpecifier === void 0) {
+              return;
+            }
+            if (isReferencedModuleImportable(namespacedImportOrExport)) {
+              addSymbolToNamespaceExports(namespaceExports2, symbol);
+              return;
+            }
+            const referencedSourceFileSymbol = (0, typescript_1.getNodeOwnSymbol)(namespacedImportOrExport.moduleSpecifier, typeChecker);
+            if (referencedSourceFileSymbol.exports === void 0) {
+              return;
+            }
+            if (ts2.isImportDeclaration(namespacedImportOrExport) && referencedSourceFileSymbol.exports.has(ts2.InternalSymbolName.ExportEquals)) {
+              return;
+            }
+            const localNamespaceName = createNamespaceForExports(referencedSourceFileSymbol.exports, symbol);
+            if (localNamespaceName !== null) {
+              namespaceExports2.set(symbol.getName(), localNamespaceName);
+            }
+          }
+          function processExportSymbol(namespaceExports2, symbol) {
+            if (symbol.escapedName === ts2.InternalSymbolName.ExportStar) {
+              for (const exportStarDeclaration of (0, typescript_1.getSymbolExportStarDeclarations)(symbol)) {
+                if (exportStarDeclaration.moduleSpecifier === void 0) {
+                  throw new Error(`Export star declaration does not have a module specifier '${exportStarDeclaration.getText()}'`);
+                }
+                if (isReferencedModuleImportable(exportStarDeclaration)) {
+                  throw new Error(`Having a re-export from an importable module as a part of namespaced export is not supported yet.`);
+                }
+                const referencedSourceFileSymbol = (0, typescript_1.getNodeOwnSymbol)(exportStarDeclaration.moduleSpecifier, typeChecker);
+                referencedSourceFileSymbol.exports?.forEach(processExportSymbol.bind(null, namespaceExports2));
+              }
+              return;
+            }
+            symbol.declarations?.forEach((decl) => {
+              if (ts2.isNamespaceExport(decl) && decl.parent.moduleSpecifier !== void 0) {
+                handleNamespacedImportOrExport(decl.parent, namespaceExports2, symbol);
+                return;
+              }
+              if (ts2.isExportSpecifier(decl)) {
+                const exportElementSymbol = (0, typescript_1.getImportExportReferencedSymbol)(decl, typeChecker);
+                const namespaceImport = (0, typescript_1.getDeclarationsForSymbol)(exportElementSymbol).find(ts2.isNamespaceImport);
+                if (namespaceImport !== void 0) {
+                  handleNamespacedImportOrExport(namespaceImport.parent.parent, namespaceExports2, symbol);
+                }
+                return;
+              }
+            });
+            addSymbolToNamespaceExports(namespaceExports2, symbol);
+          }
+          function getIdentifierOfNamespaceImportFromInlinedModule(nsSymbol) {
+            for (const decl of (0, typescript_1.getDeclarationsForSymbol)(nsSymbol)) {
+              if (!ts2.isNamespaceExport(decl) && !ts2.isExportSpecifier(decl) && !ts2.isNamespaceImport(decl)) {
+                continue;
+              }
+              if (ts2.isNamespaceExport(decl) && !isReferencedModuleImportable(decl.parent)) {
+                return decl.name;
+              }
+              if (ts2.isNamespaceImport(decl) && !isReferencedModuleImportable(decl.parent.parent)) {
+                return decl.name;
+              }
+              if (ts2.isExportSpecifier(decl)) {
+                if (decl.parent.parent.moduleSpecifier !== void 0) {
+                  if (isReferencedModuleImportable(decl.parent.parent)) {
+                    continue;
+                  }
+                  if (getIdentifierOfNamespaceImportFromInlinedModule((0, typescript_1.getImportExportReferencedSymbol)(decl, typeChecker))) {
+                    return decl.name;
+                  }
+                }
+                const result = (0, typescript_1.getDeclarationsForSymbol)((0, typescript_1.getImportExportReferencedSymbol)(decl, typeChecker)).some((importDecl) => {
+                  if (ts2.isNamespaceImport(importDecl)) {
+                    return !isReferencedModuleImportable(importDecl.parent.parent);
+                  }
+                  if (ts2.isImportSpecifier(importDecl)) {
+                    return getIdentifierOfNamespaceImportFromInlinedModule((0, typescript_1.getImportExportReferencedSymbol)(importDecl, typeChecker));
+                  }
+                  return false;
+                });
+                if (result) {
+                  return decl.name;
+                }
+              }
+            }
+            return null;
+          }
+          const namespaceNameIdentifier = getIdentifierOfNamespaceImportFromInlinedModule(namespaceSymbol);
+          if (namespaceNameIdentifier === null) {
+            return null;
+          }
+          const namespaceExports = /* @__PURE__ */ new Map();
+          exports2.forEach(processExportSymbol.bind(null, namespaceExports));
+          if (namespaceExports.size !== 0) {
+            const namespaceLocalName = collisionsResolver.addTopLevelIdentifier(namespaceNameIdentifier);
+            collectionResult.wrappedNamespaces.set(namespaceLocalName, namespaceExports);
+            return namespaceLocalName;
+          }
+          return null;
+        }
+        function syncExports() {
+          for (const exp of rootFileExports) {
+            if (exp.type === 0) {
+              continue;
+            }
+            const namespaceLocalName = exp.symbol.flags & ts2.SymbolFlags.ValueModule && exp.symbol.exports !== void 0 ? createNamespaceForExports(exp.symbol.exports, exp.originalSymbol) : null;
+            if (namespaceLocalName !== null) {
+              collectionResult.renamedExports.set(exp.exportedName, namespaceLocalName);
+            }
+            const symbolKnownNames = collisionsResolver.namesForSymbol(exp.symbol);
+            if (symbolKnownNames.size === 0) {
+              continue;
+            }
+            if (symbolKnownNames.has(exp.exportedName)) {
+              if (shouldSymbolBeImported(exp.symbol)) {
+                collectionResult.renamedExports.set(exp.exportedName, exp.exportedName);
+              }
+              continue;
+            }
+            collectionResult.renamedExports.set(exp.exportedName, Array.from(symbolKnownNames)[0]);
+          }
+        }
+        for (const sourceFile of sourceFiles) {
+          (0, logger_1.verboseLog)(`======= Processing ${sourceFile.fileName} =======`);
+          const updateFn = sourceFile === rootSourceFile ? updateResultForRootModule : updateResultForAnyModule;
+          const currentModule = (0, module_info_1.getFileModuleInfo)(sourceFile.fileName, criteria);
+          updateFn(sourceFile.statements, currentModule);
+          if (isNodeUsed(sourceFile)) {
+            switch (currentModule.type) {
+              case 1: {
+                updateImportsForStatement(sourceFile);
+                break;
+              }
+              case 0: {
+                const sourceFileSymbol = (0, typescript_1.getNodeSymbol)(sourceFile, typeChecker);
+                if (sourceFileSymbol === null || sourceFileSymbol.exports === void 0) {
+                  throw new Error(`Cannot find symbol or exports for source file ${sourceFile.fileName}`);
+                }
+                let namespaceIdentifier = null;
+                forEachImportOfStatement(sourceFile, (imp) => {
+                  if (ts2.isNamespaceExport(imp) || ts2.isNamespaceImport(imp)) {
+                    namespaceIdentifier = imp.name;
+                  }
+                });
+                if (namespaceIdentifier === null) {
+                  break;
+                }
+                createNamespaceForExports(sourceFileSymbol.exports, (0, typescript_1.getNodeOwnSymbol)(namespaceIdentifier, typeChecker));
+                break;
+              }
+            }
+          }
+        }
+        if (entryConfig.failOnClass) {
+          const classes = collectionResult.statements.filter(ts2.isClassDeclaration);
+          if (classes.length !== 0) {
+            const classesNames = classes.map((c) => c.name === void 0 ? "anonymous class" : c.name.text);
+            throw new Error(`${classes.length} class statement(s) are found in generated dts: ${classesNames.join(", ")}`);
+          }
+        }
+        syncExports();
+        const exportReferencedTypes = outputOptions.exportReferencedTypes !== false;
+        function isExportedWithLocalName(namedDeclaration, exportedName) {
+          const nodeName = (0, typescript_1.getNodeName)(namedDeclaration);
+          if (nodeName === void 0) {
+            throw new Error(`Cannot find node name ${namedDeclaration.getText()}`);
+          }
+          return collisionsResolver.resolveReferencedIdentifier(nodeName) === exportedName;
+        }
+        const renamedAndNotExplicitlyExportedTypes = [];
+        const output = (0, generate_output_1.generateOutput)({
+          ...collectionResult,
+          resolveIdentifierName: (identifier) => {
+            if (ts2.isPropertyAccessOrQualifiedName(identifier)) {
+              return collisionsResolver.resolveReferencedQualifiedName(identifier);
+            } else {
+              return collisionsResolver.resolveReferencedIdentifier(identifier);
+            }
+          },
+          // eslint-disable-next-line complexity
+          getStatementSettings: (statement) => {
+            if ((0, typescript_1.isAmbientModule)(statement) || ts2.isExportDeclaration(statement)) {
+              return { shouldHaveExportKeyword: false, shouldHaveJSDoc: true };
+            }
+            const statementExports = (0, typescript_1.getExportsForStatement)(rootFileExports, typeChecker, statement);
+            const isExplicitlyExportedWithOriginalName = statementExports.find((exp) => {
+              if (ts2.isVariableStatement(statement)) {
+                for (const variableDeclaration of statement.declarationList.declarations) {
+                  if (ts2.isIdentifier(variableDeclaration.name)) {
+                    const resolvedName = collisionsResolver.resolveReferencedIdentifier(variableDeclaration.name);
+                    if (exp.exportedName === resolvedName) {
+                      return true;
+                    }
+                    continue;
+                  }
+                  (0, logger_1.warnLog)(`Unhandled variable identifier type detected (${ts2.SyntaxKind[variableDeclaration.name.kind]}). Please report this issue to https://github.com/timocov/dts-bundle-generator`);
+                }
+                return false;
+              }
+              return (0, typescript_1.isNodeNamedDeclaration)(statement) && isExportedWithLocalName(statement, exp.exportedName);
+            }) !== void 0;
+            const onlyExplicitlyExportedShouldBeExported = !exportReferencedTypes || ts2.isClassDeclaration(statement) || ts2.isEnumDeclaration(statement) && !(0, typescript_1.hasNodeModifier)(statement, ts2.SyntaxKind.ConstKeyword) || ts2.isFunctionDeclaration(statement) || ts2.isVariableStatement(statement) || ts2.isModuleDeclaration(statement);
+            if (onlyExplicitlyExportedShouldBeExported) {
+              return { shouldHaveExportKeyword: isExplicitlyExportedWithOriginalName, shouldHaveJSDoc: statementExports.length !== 0 };
+            }
+            if ((0, typescript_1.isNodeNamedDeclaration)(statement) && !isExportedWithLocalName(statement, (0, typescript_1.getNodeName)(statement).getText())) {
+              renamedAndNotExplicitlyExportedTypes.push(statement);
+              return { shouldHaveExportKeyword: false, shouldHaveJSDoc: statementExports.length !== 0 };
+            }
+            return { shouldHaveExportKeyword: isExplicitlyExportedWithOriginalName || statementExports.length === 0, shouldHaveJSDoc: true };
+          },
+          needStripConstFromConstEnum: (constEnum) => {
+            if (!program.getCompilerOptions().preserveConstEnums || !outputOptions.respectPreserveConstEnum) {
+              return false;
+            }
+            const enumSymbol = (0, typescript_1.getNodeSymbol)(constEnum, typeChecker);
+            if (enumSymbol === null) {
+              return false;
+            }
+            return rootFileExportSymbols.includes(enumSymbol);
+          },
+          needStripImportFromImportTypeNode: (node) => {
+            if (node.qualifier === void 0) {
+              return false;
+            }
+            if (!ts2.isLiteralTypeNode(node.argument) || !ts2.isStringLiteral(node.argument.literal)) {
+              return false;
+            }
+            return (0, module_info_1.getReferencedModuleInfo)(node, criteria, typeChecker)?.type === 0;
+          }
+        }, {
+          sortStatements: outputOptions.sortNodes,
+          umdModuleName: outputOptions.umdModuleName,
+          noBanner: outputOptions.noBanner
+        });
+        if (renamedAndNotExplicitlyExportedTypes.length !== 0) {
+          (0, logger_1.warnLog)(`The following type nodes were renamed because of the name collisions and will not be exported from the generated bundle:
+- ${// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          renamedAndNotExplicitlyExportedTypes.map((node) => `${(0, typescript_1.getNodeName)(node).getText()} (from ${node.getSourceFile().fileName})`).join("\n- ")}${"\n"}This might lead to unpredictable and unexpected output, and possible breaking changes to your API.${"\n"}Consider either (re-)exporting them explicitly from the entry point, or disable --export-referenced-types option ('output.exportReferencedTypes' in the config).`);
+        }
+        return output;
+      });
+    }
+    exports.generateDtsBundle = generateDtsBundle2;
+  }
+});
+
+// src/compiler/declarations.ts
+var import_dts_bundle_generator = __toESM(require_bundle_generator(), 1);
 import { mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import ts from "typescript";
 import { ActorDefinitionError } from "../errors.js";
-class DeclarationCompiler {
-    system;
-    constructor(system = ts.sys) {
-        this.system = system;
+var DeclarationCompiler = class {
+  constructor(system = ts.sys) {
+    this.system = system;
+  }
+  system;
+  compile(program, actors, contracts) {
+    const directory = mkdtempSync(path.join(os.tmpdir(), "actor-declarations-"));
+    try {
+      return this.bundle(directory, program, actors, contracts);
+    } finally {
+      rmSync(directory, { recursive: true, force: true });
     }
-    compile(program, actors, contracts) {
-        const directory = mkdtempSync(path.join(os.tmpdir(), "actor-declarations-"));
-        try {
-            return this.bundle(directory, program, actors, contracts);
+  }
+  bundle(directory, program, actors, contracts) {
+    const packages = /* @__PURE__ */ new Map();
+    const entry = this.writeActors(directory, program, actors, contracts, packages);
+    const config = writeBundleConfig(directory, program.getCompilerOptions(), packages);
+    const [declarations] = (0, import_dts_bundle_generator.generateDtsBundle)(
+      [
+        {
+          filePath: entry,
+          libraries: { inlinedLibraries: ["durable-actors"] },
+          output: { noBanner: true, exportReferencedTypes: false, sortNodes: true }
         }
-        finally {
-            rmSync(directory, { recursive: true, force: true });
-        }
-    }
-    bundle(directory, program, actors, contracts) {
-        const packages = new Map();
-        const entry = this.writeActors(directory, program, actors, contracts, packages);
-        const config = writeBundleConfig(directory, program.getCompilerOptions(), packages);
-        const [declarations] = generateDtsBundle([
-            {
-                filePath: entry,
-                libraries: { inlinedLibraries: ["durable-actors"] },
-                output: { noBanner: true, exportReferencedTypes: false, sortNodes: true }
-            }
-        ], { preferredConfigPath: config });
-        const dependencies = Object.fromEntries(externalModules(declarations)
-            .map(specifier => {
-            const name = packageName(specifier);
-            const pkg = packages.get(name) ??
-                findPackage(specifier, program.getRootFileNames()[0], program.getCompilerOptions(), this.system);
-            return [name, pkg.version];
-        })
-            .sort(([left], [right]) => left.localeCompare(right)));
-        return { declarations, dependencies };
-    }
-    writeActors(directory, program, actors, contracts, packages) {
-        const files = emitDeclarations(program, this.system);
-        const imports = [];
-        const properties = [];
-        for (const [index, contract] of contracts.entries()) {
-            const actor = actors.find(actor => actor.name.text === contract.actorName);
-            const source = actor.getSourceFile();
-            const emitted = files.get(source.fileName);
-            const projected = projectActor(emitted, actor, contract, program.getTypeChecker());
-            const file = path.join(directory, `actor-${index}.d.ts`);
-            const code = resolveImports(projected.code, source.fileName, program.getCompilerOptions(), this.system, packages);
-            writeFileSync(file, code);
-            imports.push(`import type { ${projected.name} as Actor${index} } from "./actor-${index}.js"`);
-            properties.push(`${JSON.stringify(contract.actorName)}: Actor${index}`);
-        }
-        const entry = path.join(directory, "index.d.ts");
-        writeFileSync(entry, `${imports.join("\n")}\nexport interface ActorTypes { ${properties.join(";\n")} }`);
-        return entry;
+      ],
+      { preferredConfigPath: config }
+    );
+    const dependencies = Object.fromEntries(
+      externalModules(declarations).map((specifier) => {
+        const name = packageName(specifier);
+        const pkg = packages.get(name) ?? findPackage(specifier, program.getRootFileNames()[0], program.getCompilerOptions(), this.system);
+        return [name, pkg.version];
+      }).sort(([left], [right]) => left.localeCompare(right))
+    );
+    return { declarations, dependencies };
+  }
+  writeActors(directory, program, actors, contracts, packages) {
+    const files = emitDeclarations(program, this.system);
+    const imports = [];
+    const properties = [];
+    for (const [index, contract] of contracts.entries()) {
+      const actor = actors.find((actor2) => actor2.name.text === contract.actorName);
+      const source = actor.getSourceFile();
+      const emitted = files.get(source.fileName);
+      const projected = projectActor(emitted, actor, contract, program.getTypeChecker());
+      const file = path.join(directory, `actor-${index}.d.ts`);
+      const code = resolveImports(
+        projected.code,
+        source.fileName,
+        program.getCompilerOptions(),
+        this.system,
+        packages
+      );
+      writeFileSync(file, code);
+      imports.push(`import type { ${projected.name} as Actor${index} } from "./actor-${index}.js"`);
+      properties.push(`${JSON.stringify(contract.actorName)}: Actor${index}`);
     }
-}
+    const entry = path.join(directory, "index.d.ts");
+    writeFileSync(entry, `${imports.join("\n")}
+export interface ActorTypes { ${properties.join(";\n")} }`);
+    return entry;
+  }
+};
 function writeBundleConfig(directory, options, packages) {
-    for (const [name, pkg] of packages) {
-        const link = path.join(directory, "node_modules", name);
-        mkdirSync(path.dirname(link), { recursive: true });
-        symlinkSync(pkg.directory, link, "dir");
-    }
-    const config = path.join(directory, "tsconfig.json");
-    writeFileSync(config, JSON.stringify({
-        compilerOptions: {
-            target: "ES2022",
-            module: "NodeNext",
-            strict: true,
-            skipLibCheck: true,
-            baseUrl: options.baseUrl ?? options.pathsBasePath,
-            paths: options.paths,
-            exactOptionalPropertyTypes: options.exactOptionalPropertyTypes ?? false,
-            types: []
-        }
-    }));
-    writeFileSync(path.join(directory, "package.json"), '{"type":"module"}');
-    return config;
+  for (const [name, pkg] of packages) {
+    const link = path.join(directory, "node_modules", name);
+    mkdirSync(path.dirname(link), { recursive: true });
+    symlinkSync(pkg.directory, link, "dir");
+  }
+  const config = path.join(directory, "tsconfig.json");
+  writeFileSync(
+    config,
+    JSON.stringify({
+      compilerOptions: {
+        target: "ES2022",
+        module: "NodeNext",
+        strict: true,
+        skipLibCheck: true,
+        baseUrl: options.baseUrl ?? options.pathsBasePath,
+        paths: options.paths,
+        exactOptionalPropertyTypes: options.exactOptionalPropertyTypes ?? false,
+        types: []
+      }
+    })
+  );
+  writeFileSync(path.join(directory, "package.json"), '{"type":"module"}');
+  return config;
 }
 function emitDeclarations(program, system) {
-    const options = {
-        ...program.getCompilerOptions(),
-        noEmit: false,
-        declaration: true,
-        declarationMap: false,
-        emitDeclarationOnly: true,
-        outDir: undefined,
-        outFile: undefined,
-        incremental: false,
-        composite: false
-    };
-    const host = ts.createCompilerHost(options);
-    host.readFile = file => program.getSourceFile(file)?.text ?? system.readFile(file);
-    host.fileExists = system.fileExists;
-    const emitter = ts.createProgram(program.getRootFileNames(), options, host, program);
-    const files = new Map();
-    const result = emitter.emit(undefined, (_file, text, _bom, _error, sources) => {
-        if (sources?.length === 1)
-            files.set(sources[0].fileName, text);
-    }, undefined, true);
-    if (result.diagnostics.length)
-        throw new ActorDefinitionError(result.diagnostics.map(d => ts.flattenDiagnosticMessageText(d.messageText, "\n")).join("\n"));
-    return files;
+  const options = {
+    ...program.getCompilerOptions(),
+    noEmit: false,
+    declaration: true,
+    declarationMap: false,
+    emitDeclarationOnly: true,
+    outDir: void 0,
+    outFile: void 0,
+    incremental: false,
+    composite: false
+  };
+  const host = ts.createCompilerHost(options);
+  host.readFile = (file) => program.getSourceFile(file)?.text ?? system.readFile(file);
+  host.fileExists = system.fileExists;
+  const emitter = ts.createProgram(program.getRootFileNames(), options, host, program);
+  const files = /* @__PURE__ */ new Map();
+  const result = emitter.emit(
+    void 0,
+    (_file, text, _bom, _error, sources) => {
+      if (sources?.length === 1) files.set(sources[0].fileName, text);
+    },
+    void 0,
+    true
+  );
+  if (result.diagnostics.length)
+    throw new ActorDefinitionError(
+      result.diagnostics.map((d) => ts.flattenDiagnosticMessageText(d.messageText, "\n")).join("\n")
+    );
+  return files;
 }
 function projectActor(text, actor, contract, checker) {
-    const source = ts.createSourceFile("actor.d.ts", text, ts.ScriptTarget.Latest, true);
-    const declaration = source.statements.find(statement => ts.isClassDeclaration(statement) && statement.name?.text === actor.name.text);
-    const instance = checker.getTypeAtLocation(actor);
-    const types = checker.getTypeArguments(instance.getBaseTypes()[0]);
-    const declaredTypes = declaration.heritageClauses?.find(clause => clause.token === ts.SyntaxKind.ExtendsKeyword)
-        ?.types[0].typeArguments;
-    const name = availableName(source, `$${contract.actorName}Contract`);
-    const properties = ["Metadata", "Incoming", "Outgoing"].map((kind, index) => ts.factory.createPropertySignature(undefined, kind, undefined, declaredTypes?.[index] ??
-        checker.typeToTypeNode(types[index], undefined, ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseFullyQualifiedType)));
-    properties.push(ts.factory.createPropertySignature(undefined, "State", undefined, publicState(declaration, contract)));
-    properties.push(ts.factory.createPropertySignature(undefined, "Methods", undefined, publicMethods(declaration, contract)));
-    const root = ts.factory.createInterfaceDeclaration([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], name, undefined, undefined, properties);
-    return {
-        name,
-        code: ts.createPrinter().printFile(ts.factory.updateSourceFile(source, [...source.statements, root]))
-    };
+  const source = ts.createSourceFile("actor.d.ts", text, ts.ScriptTarget.Latest, true);
+  const declaration = source.statements.find(
+    (statement) => ts.isClassDeclaration(statement) && statement.name?.text === actor.name.text
+  );
+  const instance = checker.getTypeAtLocation(actor);
+  const types = checker.getTypeArguments(instance.getBaseTypes()[0]);
+  const declaredTypes = declaration.heritageClauses?.find((clause) => clause.token === ts.SyntaxKind.ExtendsKeyword)?.types[0].typeArguments;
+  const name = availableName(source, `$${contract.actorName}Contract`);
+  const properties = ["Metadata", "Incoming", "Outgoing"].map(
+    (kind, index) => ts.factory.createPropertySignature(
+      void 0,
+      kind,
+      void 0,
+      declaredTypes?.[index] ?? checker.typeToTypeNode(
+        types[index],
+        void 0,
+        ts.NodeBuilderFlags.NoTruncation | ts.NodeBuilderFlags.UseFullyQualifiedType
+      )
+    )
+  );
+  properties.push(
+    ts.factory.createPropertySignature(void 0, "State", void 0, publicState(declaration, contract))
+  );
+  properties.push(
+    ts.factory.createPropertySignature(void 0, "Methods", void 0, publicMethods(declaration, contract))
+  );
+  const root = ts.factory.createInterfaceDeclaration(
+    [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+    name,
+    void 0,
+    void 0,
+    properties
+  );
+  return {
+    name,
+    code: ts.createPrinter().printFile(ts.factory.updateSourceFile(source, [...source.statements, root]))
+  };
 }
 function publicState(declaration, contract) {
-    const state = declaration.members.filter(member => ts.isPropertyDeclaration(member) &&
-        Object.hasOwn(contract.socket.schema.definitions.State.properties, propertyName(member.name)));
-    return ts.factory.createTypeLiteralNode(state.map(member => ts.factory.createPropertySignature(member.modifiers?.filter(m => m.kind === ts.SyntaxKind.ReadonlyKeyword), member.name, member.questionToken, member.type)));
+  const state = declaration.members.filter(
+    (member) => ts.isPropertyDeclaration(member) && Object.hasOwn(
+      contract.socket.schema.definitions.State.properties,
+      propertyName(member.name)
+    )
+  );
+  return ts.factory.createTypeLiteralNode(
+    state.map(
+      (member) => ts.factory.createPropertySignature(
+        member.modifiers?.filter((m) => m.kind === ts.SyntaxKind.ReadonlyKeyword),
+        member.name,
+        member.questionToken,
+        member.type
+      )
+    )
+  );
 }
 function publicMethods(declaration, contract) {
-    const members = declaration.members.filter(member => ts.isMethodDeclaration(member) &&
-        contract.rpc.methods.some(method => method.name === propertyName(member.name)));
-    return ts.factory.createTypeLiteralNode(members
-        .sort((a, b) => propertyName(a.name).localeCompare(propertyName(b.name)))
-        .map(member => ts.factory.createMethodSignature(undefined, member.name, member.questionToken, member.typeParameters, member.parameters, member.type)));
+  const members = declaration.members.filter(
+    (member) => ts.isMethodDeclaration(member) && contract.rpc.methods.some((method) => method.name === propertyName(member.name))
+  );
+  return ts.factory.createTypeLiteralNode(
+    members.sort((a, b) => propertyName(a.name).localeCompare(propertyName(b.name))).map(
+      (member) => ts.factory.createMethodSignature(
+        void 0,
+        member.name,
+        member.questionToken,
+        member.typeParameters,
+        member.parameters,
+        member.type
+      )
+    )
+  );
 }
 function availableName(source, proposed) {
-    let name = proposed;
-    while (source.text.includes(name))
-        name += "_";
-    return name;
+  let name = proposed;
+  while (source.text.includes(name)) name += "_";
+  return name;
 }
 function propertyName(name) {
-    if (ts.isComputedPropertyName(name) && ts.isStringLiteral(name.expression))
-        return name.expression.text;
-    return ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name) ? name.text : name.getText();
+  if (ts.isComputedPropertyName(name) && ts.isStringLiteral(name.expression)) return name.expression.text;
+  return ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name) ? name.text : name.getText();
 }
 function resolveImports(text, location, options, system, packages) {
-    const source = ts.createSourceFile("actor.d.ts", text, ts.ScriptTarget.Latest, true);
-    const result = ts.transform(source, [
-        context => root => ts.visitNode(root, function visit(node) {
-            if (ts.isStringLiteral(node) && isModuleSpecifier(node)) {
-                const resolved = ts.resolveModuleName(node.text, location, options, system).resolvedModule;
-                if (!resolved)
-                    throw new ActorDefinitionError(`Cannot resolve public type dependency ${node.text}`);
-                if (node.text.startsWith(".") || path.isAbsolute(node.text) || !resolved.isExternalLibraryImport)
-                    return ts.factory.createStringLiteral(resolved.resolvedFileName);
-                const name = packageName(node.text);
-                packages.set(name, packageAt(resolved.resolvedFileName, name, system));
-            }
-            return ts.visitEachChild(node, visit, context);
-        })
-    ]);
-    const code = ts.createPrinter().printFile(result.transformed[0]);
-    result.dispose();
-    return code;
+  const source = ts.createSourceFile("actor.d.ts", text, ts.ScriptTarget.Latest, true);
+  const result = ts.transform(source, [
+    (context) => (root) => ts.visitNode(root, function visit(node) {
+      if (ts.isStringLiteral(node) && isModuleSpecifier(node)) {
+        const resolved = ts.resolveModuleName(node.text, location, options, system).resolvedModule;
+        if (!resolved) throw new ActorDefinitionError(`Cannot resolve public type dependency ${node.text}`);
+        if (node.text.startsWith(".") || path.isAbsolute(node.text) || !resolved.isExternalLibraryImport)
+          return ts.factory.createStringLiteral(resolved.resolvedFileName);
+        const name = packageName(node.text);
+        packages.set(name, packageAt(resolved.resolvedFileName, name, system));
+      }
+      return ts.visitEachChild(node, visit, context);
+    })
+  ]);
+  const code = ts.createPrinter().printFile(result.transformed[0]);
+  result.dispose();
+  return code;
 }
 function isModuleSpecifier(node) {
-    const parent = node.parent;
-    return (((ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent)) && parent.moduleSpecifier === node) ||
-        (ts.isLiteralTypeNode(parent) && ts.isImportTypeNode(parent.parent)));
+  const parent = node.parent;
+  return (ts.isImportDeclaration(parent) || ts.isExportDeclaration(parent)) && parent.moduleSpecifier === node || ts.isLiteralTypeNode(parent) && ts.isImportTypeNode(parent.parent);
 }
 function externalModules(code) {
-    const source = ts.createSourceFile("types.d.ts", code, ts.ScriptTarget.Latest, true);
-    const names = new Set(source.typeReferenceDirectives.map(ref => ref.fileName.startsWith("@types/") ? ref.fileName : `@types/${ref.fileName}`));
-    const visit = (node) => {
-        if (ts.isStringLiteral(node) && isModuleSpecifier(node)) {
-            if (node.text.startsWith(".") || path.isAbsolute(node.text))
-                throw new ActorDefinitionError(`Unbundled public type dependency ${node.text}`);
-            if (!node.text.startsWith("node:"))
-                names.add(node.text);
-        }
-        ts.forEachChild(node, visit);
-    };
-    visit(source);
-    return [...names].sort();
+  const source = ts.createSourceFile("types.d.ts", code, ts.ScriptTarget.Latest, true);
+  const names = new Set(
+    source.typeReferenceDirectives.map(
+      (ref) => ref.fileName.startsWith("@types/") ? ref.fileName : `@types/${ref.fileName}`
+    )
+  );
+  const visit = (node) => {
+    if (ts.isStringLiteral(node) && isModuleSpecifier(node)) {
+      if (node.text.startsWith(".") || path.isAbsolute(node.text))
+        throw new ActorDefinitionError(`Unbundled public type dependency ${node.text}`);
+      if (!node.text.startsWith("node:")) names.add(node.text);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(source);
+  return [...names].sort();
 }
 function packageName(specifier) {
-    return specifier
-        .split("/")
-        .slice(0, specifier.startsWith("@") ? 2 : 1)
-        .join("/");
+  return specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
 }
 function findPackage(specifier, location, options, system) {
-    const resolved = ts.resolveModuleName(specifier, location, options, system).resolvedModule;
-    if (!resolved)
-        throw new ActorDefinitionError(`Cannot resolve public type dependency ${specifier}`);
-    return packageAt(resolved.resolvedFileName, packageName(specifier), system);
+  const resolved = ts.resolveModuleName(specifier, location, options, system).resolvedModule;
+  if (!resolved) throw new ActorDefinitionError(`Cannot resolve public type dependency ${specifier}`);
+  return packageAt(resolved.resolvedFileName, packageName(specifier), system);
 }
 function packageAt(file, name, system) {
-    for (let directory = path.dirname(file);; directory = path.dirname(directory)) {
-        const manifest = system.readFile(path.join(directory, "package.json"));
-        if (manifest) {
-            const json = JSON.parse(manifest);
-            if (json.name === name || directory.endsWith(`${path.sep}${name}`)) {
-                if (typeof json.version !== "string")
-                    throw new ActorDefinitionError(`Public type dependency ${name} must declare a version`);
-                return { directory, version: json.version };
-            }
-        }
-        if (directory === path.dirname(directory))
-            throw new ActorDefinitionError(`Cannot find package metadata for ${name}`);
+  for (let directory = path.dirname(file); ; directory = path.dirname(directory)) {
+    const manifest = system.readFile(path.join(directory, "package.json"));
+    if (manifest) {
+      const json = JSON.parse(manifest);
+      if (json.name === name || directory.endsWith(`${path.sep}${name}`)) {
+        if (typeof json.version !== "string")
+          throw new ActorDefinitionError(`Public type dependency ${name} must declare a version`);
+        return { directory, version: json.version };
+      }
     }
+    if (directory === path.dirname(directory))
+      throw new ActorDefinitionError(`Cannot find package metadata for ${name}`);
+  }
 }
-export { DeclarationCompiler };
-//# sourceMappingURL=declarations.js.map
+export {
+  DeclarationCompiler
+};
+//# sourceMappingURL=declarations.js.map