@bunup/dts 0.14.20 → 0.14.22

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 bunup
+
+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.

package/dist/index.d.ts

@@ -18,7 +18,7 @@ type GenerateDtsOptions = {
 	* Path to the preferred tsconfig.json file
 	* By default, the closest tsconfig.json file will be used
 	*/
-	preferredTsConfigPath?: string;
+	preferredTsconfig?: string;
 	/**
 	* Controls which external modules should be resolved
 	* - `true` to resolve all external modules
@@ -44,6 +44,11 @@ type GenerateDtsOptions = {
 	* Whether to minify the generated declaration files to reduce the size of the declaration file.
 	*/
 	minify?: boolean;
+	/**
+	* Whether to use typescript native compiler for generating declaration files.
+	* When enabled, you won't need explicit type annotations for exports (which are required by default when using isolated declarations).
+	*/
+	inferTypes?: boolean;
 };
 type GenerateDtsResultFile = {
 	/**

package/dist/index.js

@@ -1,15 +1,16 @@
-// packages/dts/src/generate.ts
-import path from "node:path";
+// src/generate.ts
+import { rm } from "node:fs/promises";
+import path2 from "node:path";
 import { isolatedDeclaration } from "oxc-transform";
 import { resolveTsImportPath } from "ts-import-resolver";
 
-// packages/dts/src/constants.ts
+// src/constants.ts
 var EMPTY_EXPORT = "export {};";
 
-// packages/dts/src/fake-js.ts
+// src/fake-js.ts
 import { parse } from "@babel/parser";
 
-// packages/dts/src/re.ts
+// src/re.ts
 var IMPORT_TYPE_RE = /import\s+type\s+/g;
 var EXPORT_TYPE_RE = /export\s+type\s+/g;
 var IMPORT_EXPORT_NAMES_RE = /(import|export)\s*{([^}]*)}/g;
@@ -24,7 +25,7 @@ var TS_RE = /\.[cm]?tsx?$|\.d\.[cm]?ts$/;
 var EXTENSION_REGEX = /\.(d\.(ts|cts|mts)|[cm]?[jt]s)$/;
 var NODE_MODULES_RE = /node_modules/;
 
-// packages/dts/src/ast.ts
+// src/ast.ts
 function isLikelyVariableOrTypeName(token) {
   return CAPITAL_LETTER_RE.test(token) && !token.startsWith("/*") && !token.startsWith("@") && !token.startsWith('"') && !token.startsWith("'") && !token.startsWith("`");
 }
@@ -82,7 +83,7 @@ function getName(node, source) {
       break;
     case "VariableDeclaration": {
       const declarations = node.declarations;
-      if (declarations?.length === 1 && declarations[0].id?.type === "Identifier") {
+      if (declarations?.length === 1 && declarations[0]?.id?.type === "Identifier") {
         return declarations[0].id.name;
       }
       break;
@@ -119,7 +120,7 @@ function getAllImportNames(body) {
   return importNames;
 }
 
-// packages/dts/src/utils.ts
+// src/utils.ts
 import { existsSync } from "node:fs";
 import { normalize } from "node:path";
 import { loadConfig } from "coffi";
@@ -220,7 +221,7 @@ function minifyDts(dts) {
   }).code;
 }
 
-// packages/dts/src/fake-js.ts
+// src/fake-js.ts
 async function dtsToFakeJs(dtsContent) {
   const parsed = parse(dtsContent, {
     sourceType: "module",
@@ -242,8 +243,9 @@ async function dtsToFakeJs(dtsContent) {
       referencedNames.add(name);
     }
     const isDefaultExport = hasDefaultExportModifier(statement, statementText);
+    const varName = name || generateRandomString();
     if (isDefaultExport) {
-      result.push(`export { ${name} as default };`);
+      result.push(`export { ${varName} as default };`);
       if (isDefaultReExport(statement)) {
         continue;
       }
@@ -265,7 +267,6 @@ async function dtsToFakeJs(dtsContent) {
       statementTextWithCommentsAttatched = removeExportSyntaxes(statementTextWithCommentsAttatched);
     }
     const tokens = tokenizeText(statementTextWithCommentsAttatched, referencedNames);
-    const varName = name || generateRandomString();
     result.push(`var ${varName} = [${tokens.join(", ")}];`);
     if (isExported && !isDefaultExport && !exportedNames.has(varName)) {
       result.push(`export { ${varName} };`);
@@ -368,7 +369,7 @@ function processTokenElement(element) {
     parts.push(unescapeNewlinesAndTabs(element.quasis[0]?.value?.raw || ""));
     for (let i = 0;i < element.expressions.length; i++) {
       const expr = element.expressions[i];
-      if (expr.type === "Identifier") {
+      if (expr?.type === "Identifier") {
         parts.push(expr.name);
       }
       parts.push(unescapeNewlinesAndTabs(element.quasis[i + 1]?.value?.raw || ""));
@@ -386,7 +387,7 @@ function unescapeNewlinesAndTabs(text) {
 }
 function handleNamespace(stmt) {
   const expr = stmt.expression;
-  if (!expr || expr.type !== "CallExpression" || expr.callee?.type !== "Identifier" || expr.arguments?.length !== 2 || expr.arguments[0].type !== "Identifier" || expr.arguments[1].type !== "ObjectExpression") {
+  if (!expr || expr.type !== "CallExpression" || expr.callee?.type !== "Identifier" || expr.arguments?.length !== 2 || expr.arguments[0]?.type !== "Identifier" || expr.arguments[1]?.type !== "ObjectExpression") {
     return null;
   }
   const namespaceName = expr.arguments[0].name;
@@ -406,7 +407,7 @@ function handleNamespace(stmt) {
 }`;
 }
 
-// packages/dts/src/resolver.ts
+// src/resolver.ts
 import { dirname } from "node:path";
 import process2 from "node:process";
 import { ResolverFactory } from "oxc-resolver";
@@ -421,20 +422,18 @@ function createResolver({
     extensions: [".d.ts", ".d.mts", ".d.cts", ".ts", ".mts", ".cts"],
     tsconfig: tsconfig ? { configFile: tsconfig, references: "auto" } : undefined
   });
-  const resolutionCache = new Map;
   return (importSource, importer) => {
     if (importSource === "bun")
       return null;
-    const cacheKey = `${importSource}:${importer || ""}`;
-    if (resolutionCache.has(cacheKey)) {
-      return resolutionCache.get(cacheKey) || null;
-    }
     let shouldResolve = false;
     if (resolveOption !== undefined) {
       if (typeof resolveOption === "boolean") {
         shouldResolve = resolveOption;
       } else if (Array.isArray(resolveOption)) {
         shouldResolve = resolveOption.some((resolver2) => {
+          if (importer?.includes(resolver2.toString())) {
+            return true;
+          }
           if (typeof resolver2 === "string") {
             return resolver2 === importSource;
           }
@@ -443,36 +442,56 @@ function createResolver({
       }
     }
     if (!shouldResolve) {
-      resolutionCache.set(cacheKey, null);
       return null;
     }
     const directory = importer ? dirname(importer) : cwd;
     const resolution = resolver.sync(directory, importSource);
     if (!resolution.path) {
-      resolutionCache.set(cacheKey, null);
       return null;
     }
     const resolved = resolution.path;
     if (JS_RE.test(resolved)) {
       const dts = returnPathIfExists(resolved.replace(JS_RE, ".d.ts")) || returnPathIfExists(resolved.replace(JS_RE, ".d.mts")) || returnPathIfExists(resolved.replace(JS_RE, ".d.cts"));
-      const result2 = isTypeScriptFile(dts) ? dts : null;
-      resolutionCache.set(cacheKey, result2);
-      return result2;
+      return isTypeScriptFile(dts) ? dts : null;
     }
-    const result = isTypeScriptFile(resolved) ? resolved : null;
-    resolutionCache.set(cacheKey, result);
-    return result;
+    return isTypeScriptFile(resolved) ? resolved : null;
   };
 }
 
-// packages/dts/src/generate.ts
+// src/tsgo.ts
+import { mkdtemp } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+async function runTsgo(root, tsconfig) {
+  const tsgoPackage = import.meta.resolve("@typescript/native-preview/package.json");
+  const { default: getExePath } = await import(new URL("lib/getExePath.js", tsgoPackage).href);
+  const tsgo = getExePath();
+  const dist = await mkdtemp(path.join(tmpdir(), "bunup-dts-"));
+  const proc = Bun.spawn([
+    tsgo,
+    "--noEmit",
+    "false",
+    "--declaration",
+    "--emitDeclarationOnly",
+    ...tsconfig ? ["-p", tsconfig] : [],
+    "--outDir",
+    dist,
+    "--rootDir",
+    root,
+    "--noCheck"
+  ]);
+  await proc.exited;
+  return dist;
+}
+
+// src/generate.ts
 async function generateDts(entrypoints, options = {}) {
-  const { resolve, preferredTsConfigPath, naming } = options;
-  const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
-  const tsconfig = await loadTsConfig(cwd, preferredTsConfigPath);
-  const nonAbsoluteEntrypoints = entrypoints.filter((entrypoint) => !path.isAbsolute(entrypoint));
+  const { resolve, preferredTsconfig, naming } = options;
+  const cwd = options.cwd ? path2.resolve(options.cwd) : process.cwd();
+  const tsconfig = await loadTsConfig(cwd, preferredTsconfig);
+  const nonAbsoluteEntrypoints = entrypoints.filter((entrypoint) => !path2.isAbsolute(entrypoint));
   const resolvedEntrypoints = await getFilesFromGlobs(nonAbsoluteEntrypoints, cwd);
-  const absoluteEntrypoints = entrypoints.filter((entrypoint) => path.isAbsolute(entrypoint));
+  const absoluteEntrypoints = entrypoints.filter((entrypoint) => path2.isAbsolute(entrypoint));
   if (!filterTypescriptFiles([...resolvedEntrypoints, ...absoluteEntrypoints]).length) {
     throw new Error("One or more of the entrypoints you provided do not exist. Please check that each entrypoint points to a valid file.");
   }
@@ -482,107 +501,133 @@ async function generateDts(entrypoints, options = {}) {
     resolveOption: resolve,
     tsconfig: tsconfig.filepath
   });
-  const fakeJsPlugin = {
-    name: "fake-js",
-    setup(build) {
-      build.onResolve({ filter: /.*/ }, (args) => {
-        if (!NODE_MODULES_RE.test(args.importer)) {
-          const resolved = resolveTsImportPath({
-            importer: args.importer,
-            path: args.path,
-            cwd,
-            tsconfig: tsconfig.config
-          });
-          if (resolved && isTypeScriptFile(resolved)) {
-            return { path: resolved };
-          }
-        }
-        const resolvedFromNodeModules = resolver(args.path, args.importer);
-        if (resolvedFromNodeModules) {
-          return { path: resolvedFromNodeModules };
-        }
-        return {
-          path: args.path,
-          external: true
-        };
-      });
-      build.onLoad({ filter: /\.(ts|tsx|d\.ts|d\.mts|d\.cts)$/ }, async (args) => {
-        const sourceText = await Bun.file(args.path).text();
-        const declarationResult = isolatedDeclaration(args.path, sourceText);
-        let fakeJsContent = "";
-        if (!collectedErrors.some((e) => e.file === args.path)) {
-          for (const error of declarationResult.errors) {
-            collectedErrors.push({
-              error,
-              file: args.path,
-              content: sourceText
+  let tsgoDist;
+  try {
+    const fakeJsPlugin = {
+      name: "fake-js",
+      async setup(build) {
+        build.onResolve({ filter: /.*/ }, (args) => {
+          if (!NODE_MODULES_RE.test(args.importer)) {
+            const resolved = resolveTsImportPath({
+              importer: args.importer,
+              path: args.path,
+              cwd,
+              tsconfig: tsconfig.config
             });
+            if (resolved && isTypeScriptFile(resolved)) {
+              return { path: resolved };
+            }
           }
+          const resolvedFromNodeModules = resolver(args.path, args.importer);
+          if (resolvedFromNodeModules) {
+            return { path: resolvedFromNodeModules };
+          }
+          return {
+            path: args.path,
+            external: true
+          };
+        });
+        if (options.inferTypes) {
+          tsgoDist = await runTsgo(cwd, tsconfig.filepath ?? undefined);
         }
-        if (declarationResult.code) {
-          fakeJsContent = await dtsToFakeJs(declarationResult.code);
-        } else {
-          fakeJsContent = EMPTY_EXPORT;
-        }
-        return {
-          loader: "js",
-          contents: fakeJsContent
-        };
-      });
-    }
-  };
-  const result = await Bun.build({
-    entrypoints: [
-      ...filterTypescriptFiles(resolvedEntrypoints).map((entry) => path.resolve(path.join(cwd, entry))),
-      ...filterTypescriptFiles(absoluteEntrypoints)
-    ],
-    format: "esm",
-    target: "node",
-    naming,
-    splitting: options.splitting,
-    plugins: [fakeJsPlugin],
-    packages: "external",
-    minify: options.minify,
-    throw: false
-  });
-  if (!result.success) {
-    throw new Error(`DTS bundling failed: ${result.logs}`);
-  }
-  const outputs = result.outputs.filter((output) => output.kind === "chunk" || output.kind === "entry-point");
-  const bundledFiles = [];
-  for (const output of outputs) {
-    const bundledFakeJsContent = await output.text();
-    const dtsContent = await fakeJsToDts(bundledFakeJsContent);
-    const entrypoint = output.kind === "entry-point" ? entrypoints[bundledFiles.length] : undefined;
-    const chunkFileName = output.kind === "chunk" ? replaceExtension(path.basename(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))) : undefined;
-    const outputPath = cleanPath(replaceExtension(cleanPath(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))));
-    const treeshakedDts = isolatedDeclaration(`${generateRandomString()}.d.ts`, dtsContent);
-    if (!treeshakedDts.code.length && !treeshakedDts.errors.length) {
-      continue;
+        build.onLoad({ filter: /\.(ts|tsx|d\.ts|d\.mts|d\.cts)$/ }, async (args) => {
+          const sourceText = await Bun.file(args.path).text();
+          let declaration = "";
+          let isolatedDeclarationErrors = [];
+          if (NODE_MODULES_RE.test(args.path)) {
+            declaration = sourceText;
+          } else {
+            if (options.inferTypes && tsgoDist) {
+              const declarationPath = replaceExtension(path2.join(tsgoDist, args.path.replace(cwd, "")), ".d.ts");
+              declaration = await Bun.file(declarationPath).text();
+            } else {
+              const isolatedDeclarationResult = isolatedDeclaration(args.path, sourceText);
+              declaration = isolatedDeclarationResult.code;
+              if (isolatedDeclarationResult.errors) {
+                isolatedDeclarationErrors = isolatedDeclarationResult.errors;
+              }
+            }
+          }
+          let fakeJsContent = "";
+          if (!collectedErrors.some((e) => e.file === args.path)) {
+            for (const error of isolatedDeclarationErrors) {
+              collectedErrors.push({
+                error,
+                file: args.path,
+                content: sourceText
+              });
+            }
+          }
+          if (declaration) {
+            fakeJsContent = await dtsToFakeJs(declaration);
+          } else {
+            fakeJsContent = EMPTY_EXPORT;
+          }
+          return {
+            loader: "js",
+            contents: fakeJsContent
+          };
+        });
+      }
+    };
+    const result = await Bun.build({
+      entrypoints: [
+        ...filterTypescriptFiles(resolvedEntrypoints).map((entry) => path2.resolve(path2.join(cwd, entry))),
+        ...filterTypescriptFiles(absoluteEntrypoints)
+      ],
+      format: "esm",
+      target: "node",
+      naming,
+      splitting: options.splitting,
+      plugins: [fakeJsPlugin],
+      packages: "external",
+      minify: options.minify,
+      throw: false,
+      tsconfig: options.preferredTsconfig ? path2.resolve(cwd, options.preferredTsconfig) : undefined
+    });
+    if (!result.success) {
+      throw new Error(`DTS bundling failed: ${result.logs}`);
     }
-    if (treeshakedDts.errors.length && !treeshakedDts.code) {
-      throw new Error(`DTS treeshaking failed for ${entrypoint || outputPath}
+    const outputs = result.outputs.filter((output) => output.kind === "chunk" || output.kind === "entry-point");
+    const bundledFiles = [];
+    for (const output of outputs) {
+      const bundledFakeJsContent = await output.text();
+      const dtsContent = await fakeJsToDts(bundledFakeJsContent);
+      const entrypoint = output.kind === "entry-point" ? entrypoints[bundledFiles.length] : undefined;
+      const chunkFileName = output.kind === "chunk" ? replaceExtension(path2.basename(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))) : undefined;
+      const outputPath = cleanPath(replaceExtension(cleanPath(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))));
+      const treeshakedDts = isolatedDeclaration(`${generateRandomString()}.d.ts`, dtsContent);
+      if (!treeshakedDts.code.length && !treeshakedDts.errors.length) {
+        continue;
+      }
+      if (treeshakedDts.errors.length && !treeshakedDts.code) {
+        throw new Error(`DTS treeshaking failed for ${entrypoint || outputPath}
 
 ${JSON.stringify(treeshakedDts.errors, null, 2)}`);
-    }
-    bundledFiles.push({
-      kind: output.kind === "entry-point" ? "entry-point" : "chunk",
-      entrypoint,
-      chunkFileName,
-      outputPath,
-      dts: options.minify ? minifyDts(treeshakedDts.code) : treeshakedDts.code,
-      pathInfo: {
-        outputPathWithoutExtension: deleteExtension(outputPath),
-        ext: getExtension(outputPath)
       }
-    });
+      bundledFiles.push({
+        kind: output.kind === "entry-point" ? "entry-point" : "chunk",
+        entrypoint,
+        chunkFileName,
+        outputPath,
+        dts: options.minify ? minifyDts(treeshakedDts.code) : treeshakedDts.code,
+        pathInfo: {
+          outputPathWithoutExtension: deleteExtension(outputPath),
+          ext: getExtension(outputPath)
+        }
+      });
+    }
+    return {
+      files: bundledFiles,
+      errors: collectedErrors
+    };
+  } finally {
+    if (tsgoDist) {
+      await rm(tsgoDist, { recursive: true, force: true });
+    }
   }
-  return {
-    files: bundledFiles,
-    errors: collectedErrors
-  };
 }
-// packages/dts/src/isolated-decl-logger.ts
+// src/isolated-decl-logger.ts
 import pc from "picocolors";
 var SEVERITY_CONFIG = {
   dev: {
@@ -651,7 +696,7 @@ ${pc.gray(codeFrame)}
 `);
 }
 function extractErrorCode(message) {
-  return message.split(":")[0];
+  return message.split(":")[0] ?? "";
 }
 function getSeverityFormatting(severity) {
   const config = SEVERITY_CONFIG[isDev() ? "dev" : "prod"];
@@ -663,7 +708,10 @@ function calculatePosition(sourceText, labelStart) {
   const lines = sourceText.slice(0, labelStart).split(`
 `);
   const lineNumber = lines.length;
-  const columnStart = lines[lines.length - 1].length + 1;
+  const lastLine = lines[lines.length - 1];
+  if (!lastLine)
+    return "";
+  const columnStart = lastLine.length + 1;
   return ` (${lineNumber}:${columnStart})`;
 }
 function generateOxcCodeFrame(sourceText, start, end) {
@@ -675,7 +723,7 @@ function generateOxcCodeFrame(sourceText, start, end) {
   const lastNewlineIndex = sourceText.slice(0, start).lastIndexOf(`
 `);
   const startCol = start - lastNewlineIndex - 1;
-  const endCol = end ? Math.min(end - lastNewlineIndex - 1, lineContent.length) : startCol + 1;
+  const endCol = end ? Math.min(end - lastNewlineIndex - 1, lineContent?.length ?? 0) : startCol + 1;
   const underlineLength = Math.max(1, endCol - startCol);
   const arrowLine = " ".repeat(startCol) + pc.dim(pc.blue("⎯".repeat(underlineLength)));
   return `${lineContent}

package/package.json

@@ -1,24 +1,22 @@
 {
 	"name": "@bunup/dts",
-	"description": "An extremely fast TypeScript declaration file generator and bundler that outputs to a single file.",
-	"version": "0.14.20",
-	"type": "module",
+	"version": "0.14.22",
+	"description": "An extremely fast TypeScript declaration bundler built on Bun's native bundler.",
+	"homepage": "https://github.com/bunup/dts#readme",
+	"bugs": {
+		"url": "https://github.com/bunup/dts/issues"
+	},
+	"license": "MIT",
 	"files": [
 		"dist"
 	],
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		".": {
-			"import": {
-				"types": "./dist/index.d.ts",
-				"default": "./dist/index.js"
-			}
-		},
-		"./package.json": "./package.json"
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/bunup/dts.git"
 	},
 	"dependencies": {
 		"@babel/parser": "^7.28.4",
+		"@typescript/native-preview": "^7.0.0-dev.20251016.1",
 		"coffi": "^0.1.37",
 		"oxc-minify": "^0.93.0",
 		"oxc-resolver": "^11.9.0",
@@ -27,15 +25,31 @@
 		"std-env": "^3.9.0",
 		"ts-import-resolver": "^0.1.23"
 	},
-	"license": "MIT",
-	"author": "Arshad Yaseen <m@arshadyaseen.com> (https://arshadyaseen.com)",
-	"maintainers": [
-		{
-			"name": "Arshad Yaseen",
-			"email": "m@arshadyaseen.com",
-			"url": "https://arshadyaseen.com"
-		}
-	],
+	"scripts": {
+		"build": "bunup",
+		"dev": "bunup --watch",
+		"postinstall": "bun simple-git-hooks",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"release": "bumpp --commit --push --tag",
+		"test": "bun test",
+		"test:coverage": "bun test --coverage",
+		"test:watch": "bun test --watch",
+		"type-check": "tsc --noEmit"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "^2.2.6",
+		"@types/bun": "^1.3.0",
+		"bumpp": "^10.3.1",
+		"bunup": "^0.14.21",
+		"simple-git-hooks": "^2.13.1",
+		"type-fest": "^5.1.0",
+		"typescript": "^5.9.3",
+		"zod": "^4.1.12"
+	},
+	"peerDependencies": {
+		"typescript": ">=4.5.0"
+	},
 	"keywords": [
 		"typescript",
 		"dts",
@@ -44,21 +58,24 @@
 		"bun",
 		"bun dts"
 	],
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/bunup/bunup.git"
-	},
-	"funding": "https://github.com/sponsors/arshad-yaseen",
-	"homepage": "https://bunup.dev",
-	"peerDependencies": {
-		"typescript": "latest"
-	},
 	"peerDependenciesMeta": {
 		"typescript": {
 			"optional": true
 		}
 	},
-	"devDependencies": {
-		"@babel/types": "^7.28.4"
-	}
+	"type": "module",
+	"exports": {
+		".": {
+			"import": {
+				"types": "./dist/index.d.ts",
+				"default": "./dist/index.js"
+			}
+		},
+		"./package.json": "./package.json"
+	},
+	"module": "./dist/index.js",
+	"simple-git-hooks": {
+		"pre-commit": "bun run lint && bun run type-check"
+	},
+	"types": "./dist/index.d.ts"
 }