mcp-use 1.2.5-dev.3 → 1.2.5-dev.5

package/dist/src/server/index.js

@@ -118,6 +118,149 @@ function createUIResourceFromDefinition(definition, params, config) {
 }
 __name(createUIResourceFromDefinition, "createUIResourceFromDefinition");
 
+// src/server/connect-adapter.ts
+function isExpressMiddleware(middleware) {
+  if (!middleware || typeof middleware !== "function") {
+    return false;
+  }
+  const paramCount = middleware.length;
+  if (paramCount === 3 || paramCount === 4) {
+    return true;
+  }
+  if (paramCount === 2) {
+    const fnString = middleware.toString();
+    const expressPatterns = [
+      /\bres\.(send|json|status|end|redirect|render|sendFile|download)\b/,
+      /\breq\.(body|params|query|cookies|session)\b/,
+      /\breq\.get\s*\(/,
+      /\bres\.set\s*\(/
+    ];
+    const hasExpressPattern = expressPatterns.some(
+      (pattern) => pattern.test(fnString)
+    );
+    if (hasExpressPattern) {
+      return true;
+    }
+    return false;
+  }
+  return false;
+}
+__name(isExpressMiddleware, "isExpressMiddleware");
+async function adaptMiddleware(middleware, middlewarePath = "*") {
+  if (isExpressMiddleware(middleware)) {
+    return adaptConnectMiddleware(middleware, middlewarePath);
+  }
+  return middleware;
+}
+__name(adaptMiddleware, "adaptMiddleware");
+async function adaptConnectMiddleware(connectMiddleware, middlewarePath) {
+  let createRequest;
+  let createResponse;
+  try {
+    const httpMocks = await import("node-mocks-http");
+    createRequest = httpMocks.createRequest;
+    createResponse = httpMocks.createResponse;
+  } catch (error) {
+    console.error(
+      "[WIDGETS] node-mocks-http not available. Install connect and node-mocks-http for Vite middleware support."
+    );
+    throw error;
+  }
+  let normalizedPath = middlewarePath;
+  if (normalizedPath.endsWith("*")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  if (normalizedPath.endsWith("/")) {
+    normalizedPath = normalizedPath.slice(0, -1);
+  }
+  const honoMiddleware = /* @__PURE__ */ __name(async (c, next) => {
+    const request = c.req.raw;
+    const parsedURL = new URL(request.url, "http://localhost");
+    const query = {};
+    for (const [key, value] of parsedURL.searchParams.entries()) {
+      query[key] = value;
+    }
+    let middlewarePathname = parsedURL.pathname;
+    if (normalizedPath && middlewarePathname.startsWith(normalizedPath)) {
+      middlewarePathname = middlewarePathname.substring(normalizedPath.length);
+      if (middlewarePathname === "") {
+        middlewarePathname = "/";
+      } else if (!middlewarePathname.startsWith("/")) {
+        middlewarePathname = "/" + middlewarePathname;
+      }
+    }
+    const mockRequest = createRequest({
+      method: request.method.toUpperCase(),
+      url: middlewarePathname + parsedURL.search,
+      headers: Object.fromEntries(request.headers.entries()),
+      query,
+      ...request.body && { body: request.body }
+    });
+    const mockResponse = createResponse();
+    let responseResolved = false;
+    const res = await new Promise((resolve) => {
+      const originalEnd = mockResponse.end.bind(mockResponse);
+      mockResponse.end = (...args) => {
+        const result = originalEnd(...args);
+        if (!responseResolved && mockResponse.writableEnded) {
+          responseResolved = true;
+          const statusCode = mockResponse.statusCode;
+          const noBodyStatuses = [204, 304];
+          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
+          const connectResponse = new Response(responseBody, {
+            status: statusCode,
+            statusText: mockResponse.statusMessage,
+            headers: mockResponse.getHeaders()
+          });
+          resolve(connectResponse);
+        }
+        return result;
+      };
+      connectMiddleware(mockRequest, mockResponse, () => {
+        if (!responseResolved && !mockResponse.writableEnded) {
+          responseResolved = true;
+          const statusCode = mockResponse.statusCode;
+          const noBodyStatuses = [204, 304];
+          const responseBody = noBodyStatuses.includes(statusCode) ? null : mockResponse._getData() || mockResponse._getBuffer() || null;
+          const preparedHeaders = c.newResponse(null, 204, {}).headers;
+          for (const key of [...preparedHeaders.keys()]) {
+            if (preparedHeaders.has(key)) {
+              c.header(key, void 0);
+            }
+            if (c.res && c.res.headers.has(key)) {
+              c.res.headers.delete(key);
+            }
+          }
+          const connectHeaders = mockResponse.getHeaders();
+          for (const [key, value] of Object.entries(connectHeaders)) {
+            if (value !== void 0) {
+              c.header(
+                key,
+                Array.isArray(value) ? value.join(", ") : String(value)
+              );
+            }
+          }
+          c.status(statusCode);
+          if (noBodyStatuses.includes(statusCode)) {
+            resolve(c.newResponse(null, statusCode));
+          } else if (responseBody) {
+            resolve(c.body(responseBody));
+          } else {
+            resolve(void 0);
+          }
+        }
+      });
+    });
+    if (res) {
+      c.res = res;
+      return res;
+    }
+    await next();
+  }, "honoMiddleware");
+  return honoMiddleware;
+}
+__name(adaptConnectMiddleware, "adaptConnectMiddleware");
+
 // src/server/logging.ts
 async function requestLogger(c, next) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().substring(11, 23);
@@ -126,7 +269,8 @@ async function requestLogger(c, next) {
   let body = null;
   if (method === "POST" && url.includes("/mcp")) {
     try {
-      body = await c.req.json().catch(() => null);
+      const clonedRequest = c.req.raw.clone();
+      body = await clonedRequest.json().catch(() => null);
     } catch {
     }
   }
@@ -184,7 +328,10 @@ var fsHelpers = {
     }
     const { readFileSync } = await import("fs");
     const buffer = readFileSync(path);
-    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+    return buffer.buffer.slice(
+      buffer.byteOffset,
+      buffer.byteOffset + buffer.byteLength
+    );
   },
   async existsSync(path) {
     if (isDeno) {
@@ -279,6 +426,52 @@ var McpServer = class {
     this.app.use("*", requestLogger);
     return new Proxy(this, {
       get(target, prop) {
+        if (prop === "use") {
+          return (...args) => {
+            const hasPath = typeof args[0] === "string";
+            const path = hasPath ? args[0] : "*";
+            const handlers = hasPath ? args.slice(1) : args;
+            const adaptedHandlers = handlers.map((handler) => {
+              if (isExpressMiddleware(handler)) {
+                return { __isExpressMiddleware: true, handler, path };
+              }
+              return handler;
+            });
+            const hasExpressMiddleware = adaptedHandlers.some(
+              (h) => h.__isExpressMiddleware
+            );
+            if (hasExpressMiddleware) {
+              Promise.all(
+                adaptedHandlers.map(async (h) => {
+                  if (h.__isExpressMiddleware) {
+                    const adapted = await adaptConnectMiddleware(
+                      h.handler,
+                      h.path
+                    );
+                    if (hasPath) {
+                      target.app.use(path, adapted);
+                    } else {
+                      target.app.use(adapted);
+                    }
+                  } else {
+                    if (hasPath) {
+                      target.app.use(path, h);
+                    } else {
+                      target.app.use(h);
+                    }
+                  }
+                })
+              ).catch((err) => {
+                console.error(
+                  "[MIDDLEWARE] Failed to adapt Express middleware:",
+                  err
+                );
+              });
+              return target;
+            }
+            return target.app.use(...args);
+          };
+        }
         if (prop in target) {
           return target[prop];
         }
@@ -845,13 +1038,11 @@ var McpServer = class {
    * @returns Promise that resolves when all widgets are mounted
    */
   async mountWidgets(options) {
-    if (this.isProductionMode()) {
+    if (this.isProductionMode() || isDeno) {
+      console.log("[WIDGETS] Mounting widgets in production mode");
       await this.mountWidgetsProduction(options);
     } else {
-      if (isDeno) {
-        console.log("[WIDGETS] Skipping dev mode widget mounting in Deno runtime (use production build)");
-        return;
-      }
+      console.log("[WIDGETS] Mounting widgets in development mode");
       await this.mountWidgetsDev(options);
     }
   }
@@ -902,13 +1093,21 @@ var McpServer = class {
     try {
       const viteModule = await new Function('return import("vite")')();
       createServer = viteModule.createServer;
-      const reactModule = await new Function('return import("@vitejs/plugin-react")')();
+      const reactModule = await new Function(
+        'return import("@vitejs/plugin-react")'
+      )();
       react = reactModule.default;
-      const tailwindModule = await new Function('return import("@tailwindcss/vite")')();
+      const tailwindModule = await new Function(
+        'return import("@tailwindcss/vite")'
+      )();
       tailwindcss = tailwindModule.default;
     } catch (error) {
-      console.error("[WIDGETS] Dev dependencies not available. Install vite, @vitejs/plugin-react, and @tailwindcss/vite for widget development.");
-      console.error("[WIDGETS] For production, use 'mcp-use build' to pre-build widgets.");
+      console.error(
+        "[WIDGETS] Dev dependencies not available. Install vite, @vitejs/plugin-react, and @tailwindcss/vite for widget development."
+      );
+      console.error(
+        "[WIDGETS] For production, use 'mcp-use build' to pre-build widgets."
+      );
       return;
     }
     const widgets = entries.map((entry) => {
@@ -924,16 +1123,17 @@ var McpServer = class {
       const widgetTempDir = pathHelpers.join(tempDir, widget.name);
       await fs.mkdir(widgetTempDir, { recursive: true });
       const resourcesPath = pathHelpers.join(getCwd(), resourcesDir);
-      const relativeResourcesPath = pathHelpers.relative(
-        widgetTempDir,
-        resourcesPath
-      ).replace(/\\/g, "/");
+      const relativeResourcesPath = pathHelpers.relative(widgetTempDir, resourcesPath).replace(/\\/g, "/");
       const cssContent = `@import "tailwindcss";
 
 /* Configure Tailwind to scan the resources directory */
 @source "${relativeResourcesPath}";
 `;
-      await fs.writeFile(pathHelpers.join(widgetTempDir, "styles.css"), cssContent, "utf8");
+      await fs.writeFile(
+        pathHelpers.join(widgetTempDir, "styles.css"),
+        cssContent,
+        "utf8"
+      );
       const entryContent = `import React from 'react'
 import { createRoot } from 'react-dom/client'
 import './styles.css'
@@ -986,67 +1186,6 @@ if (container && Component) {
         origin: serverOrigin
       }
     });
-    const adaptExpressMiddleware = /* @__PURE__ */ __name((middleware) => {
-      return async (c, next) => {
-        const req = c.req.raw;
-        let handled = false;
-        const responseBody = [];
-        let statusCode = 200;
-        const headers = {};
-        const res = {
-          statusCode: 200,
-          status: /* @__PURE__ */ __name((code) => {
-            statusCode = code;
-            res.statusCode = code;
-            return res;
-          }, "status"),
-          setHeader: /* @__PURE__ */ __name((name, value) => {
-            headers[name] = value;
-          }, "setHeader"),
-          getHeader: /* @__PURE__ */ __name((name) => headers[name], "getHeader"),
-          write: /* @__PURE__ */ __name((chunk) => {
-            responseBody.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
-          }, "write"),
-          end: /* @__PURE__ */ __name((chunk) => {
-            if (chunk) {
-              responseBody.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
-            }
-            handled = true;
-          }, "end"),
-          on: /* @__PURE__ */ __name(() => {
-          }, "on"),
-          once: /* @__PURE__ */ __name(() => {
-          }, "once"),
-          removeListener: /* @__PURE__ */ __name(() => {
-          }, "removeListener")
-        };
-        const expressReq = {
-          ...req,
-          url: new URL(req.url).pathname + new URL(req.url).search,
-          originalUrl: req.url,
-          baseUrl: "",
-          path: new URL(req.url).pathname,
-          query: Object.fromEntries(new URL(req.url).searchParams),
-          params: {},
-          body: {},
-          headers: Object.fromEntries(req.headers.entries())
-        };
-        await new Promise((resolve, reject) => {
-          middleware(expressReq, res, (err) => {
-            if (err) reject(err);
-            else resolve();
-          });
-        });
-        if (handled) {
-          const body = Buffer.concat(responseBody);
-          return new Response(body, {
-            status: statusCode,
-            headers
-          });
-        }
-        return next();
-      };
-    }, "adaptExpressMiddleware");
     this.app.use(`${baseRoute}/*`, async (c, next) => {
       const url = new URL(c.req.url);
       const pathname = url.pathname;
@@ -1074,7 +1213,11 @@ if (container && Component) {
       }
       await next();
     });
-    this.app.use(`${baseRoute}/*`, adaptExpressMiddleware(viteServer.middlewares));
+    const viteMiddleware = await adaptConnectMiddleware(
+      viteServer.middlewares,
+      `${baseRoute}/*`
+    );
+    this.app.use(`${baseRoute}/*`, viteMiddleware);
     widgets.forEach((widget) => {
       console.log(
         `[WIDGET] ${widget.name} mounted at ${baseRoute}/${widget.name}`
@@ -1214,26 +1357,46 @@ if (container && Component) {
    */
   async mountWidgetsProduction(options) {
     const baseRoute = options?.baseRoute || "/mcp-use/widgets";
-    const widgetsDir = pathHelpers.join(getCwd(), "dist", "resources", "widgets");
-    if (!await fsHelpers.existsSync(widgetsDir)) {
+    const widgetsDir = pathHelpers.join(
+      getCwd(),
+      "dist",
+      "resources",
+      "widgets"
+    );
+    console.log("widgetsDir", widgetsDir);
+    this.setupWidgetRoutes();
+    const manifestPath = pathHelpers.join(getCwd(), "dist", ".mcp-use-manifest.json");
+    let widgets = [];
+    try {
+      const manifestContent = await fsHelpers.readFileSync(manifestPath, "utf8");
+      const manifest = JSON.parse(manifestContent);
+      if (manifest.widgets && Array.isArray(manifest.widgets)) {
+        widgets = manifest.widgets;
+        console.log(`[WIDGETS] Loaded ${widgets.length} widget(s) from manifest`);
+      } else {
+        console.log("[WIDGETS] No widgets array found in manifest");
+      }
+    } catch (error) {
       console.log(
-        "[WIDGETS] No dist/resources/widgets/ directory found - skipping widget serving"
+        "[WIDGETS] Could not read manifest file, falling back to directory listing:",
+        error
       );
-      return;
-    }
-    this.setupWidgetRoutes();
-    const allEntries = await fsHelpers.readdirSync(widgetsDir);
-    const widgets = [];
-    for (const name of allEntries) {
-      const widgetPath = pathHelpers.join(widgetsDir, name);
-      const indexPath = pathHelpers.join(widgetPath, "index.html");
-      if (await fsHelpers.existsSync(indexPath)) {
-        widgets.push(name);
+      try {
+        const allEntries = await fsHelpers.readdirSync(widgetsDir);
+        for (const name of allEntries) {
+          const widgetPath = pathHelpers.join(widgetsDir, name);
+          const indexPath = pathHelpers.join(widgetPath, "index.html");
+          if (await fsHelpers.existsSync(indexPath)) {
+            widgets.push(name);
+          }
+        }
+      } catch (dirError) {
+        console.log("[WIDGETS] Directory listing also failed:", dirError);
       }
     }
     if (widgets.length === 0) {
       console.log(
-        "[WIDGETS] No built widgets found in dist/resources/widgets/"
+        "[WIDGETS] No built widgets found"
       );
       return;
     }
@@ -1294,7 +1457,10 @@ if (container && Component) {
       let props = {};
       let description = `Widget: ${widgetName}`;
       try {
-        const metadataContent = await fsHelpers.readFileSync(metadataPath, "utf8");
+        const metadataContent = await fsHelpers.readFileSync(
+          metadataPath,
+          "utf8"
+        );
         metadata = JSON.parse(metadataContent);
         if (metadata.description) {
           description = metadata.description;
@@ -1462,23 +1628,27 @@ if (container && Component) {
           }
         }, "send")
       };
-      return { expressReq, expressRes, getResponse: /* @__PURE__ */ __name(() => {
-        if (ended) {
-          if (responseBody.length > 0) {
-            const body = isDeno ? Buffer.concat(responseBody) : Buffer.concat(responseBody);
-            return new Response(body, {
-              status: statusCode,
-              headers
-            });
-          } else {
-            return new Response(null, {
-              status: statusCode,
-              headers
-            });
+      return {
+        expressReq,
+        expressRes,
+        getResponse: /* @__PURE__ */ __name(() => {
+          if (ended) {
+            if (responseBody.length > 0) {
+              const body = isDeno ? Buffer.concat(responseBody) : Buffer.concat(responseBody);
+              return new Response(body, {
+                status: statusCode,
+                headers
+              });
+            } else {
+              return new Response(null, {
+                status: statusCode,
+                headers
+              });
+            }
           }
-        }
-        return null;
-      }, "getResponse") };
+          return null;
+        }, "getResponse")
+      };
     }, "createExpressLikeObjects");
     this.app.post(endpoint, async (c) => {
       const { expressReq, expressRes, getResponse } = createExpressLikeObjects(c);
@@ -1619,14 +1789,16 @@ if (container && Component) {
    * Unlike `listen()`, this method does not start a server - it only prepares the
    * routes and returns the handler function that can be used with external servers.
    *
+   * @param options - Optional configuration for the handler
+   * @param options.provider - Platform provider (e.g., 'supabase') to handle platform-specific path rewriting
    * @returns Promise that resolves to the fetch handler function
    *
    * @example
    * ```typescript
-   * // For Supabase Edge Functions
+   * // For Supabase Edge Functions (handles path rewriting automatically)
    * const server = createMCPServer('my-server');
    * server.tool({ ... });
-   * const handler = await server.getHandler();
+   * const handler = await server.getHandler({ provider: 'supabase' });
    * Deno.serve(handler);
    * ```
    *
@@ -1639,14 +1811,46 @@ if (container && Component) {
    * export default { fetch: handler };
    * ```
    */
-  async getHandler() {
+  async getHandler(options) {
+    console.log("[MCP] Mounting widgets");
     await this.mountWidgets({
       baseRoute: "/mcp-use/widgets",
       resourcesDir: "resources"
     });
+    console.log("[MCP] Mounted widgets");
     await this.mountMcp();
+    console.log("[MCP] Mounted MCP");
+    console.log("[MCP] Mounting inspector");
     await this.mountInspector();
+    console.log("[MCP] Mounted inspector");
     const fetchHandler = this.app.fetch.bind(this.app);
+    if (options?.provider === "supabase") {
+      return async (req) => {
+        const url = new URL(req.url);
+        const pathname = url.pathname;
+        let newPathname = pathname;
+        const functionsMatch = pathname.match(
+          /^\/functions\/v1\/[^/]+(\/.*)?$/
+        );
+        if (functionsMatch) {
+          newPathname = functionsMatch[1] || "/";
+        } else {
+          const functionNameMatch = pathname.match(/^\/([^/]+)(\/.*)?$/);
+          if (functionNameMatch && functionNameMatch[2]) {
+            newPathname = functionNameMatch[2] || "/";
+          }
+        }
+        const newUrl = new URL(newPathname + url.search, url.origin);
+        const newReq = new Request(newUrl, {
+          method: req.method,
+          headers: req.headers,
+          body: req.body,
+          redirect: req.redirect
+        });
+        const result = await fetchHandler(newReq);
+        return result;
+      };
+    }
     return async (req) => {
       const result = await fetchHandler(req);
       return result;
@@ -1746,11 +1950,21 @@ if (container && Component) {
     });
     this.app.get("/mcp-use/widgets/assets/*", async (c) => {
       const assetFile = c.req.path.split("/assets/")[1];
-      const widgetsDir = pathHelpers.join(getCwd(), "dist", "resources", "widgets");
+      const widgetsDir = pathHelpers.join(
+        getCwd(),
+        "dist",
+        "resources",
+        "widgets"
+      );
       try {
         const widgets = await fsHelpers.readdirSync(widgetsDir);
         for (const widget of widgets) {
-          const assetPath = pathHelpers.join(widgetsDir, widget, "assets", assetFile);
+          const assetPath = pathHelpers.join(
+            widgetsDir,
+            widget,
+            "assets",
+            assetFile
+          );
           if (await fsHelpers.existsSync(assetPath)) {
             const content = await fsHelpers.readFile(assetPath);
             const ext = assetFile.split(".").pop()?.toLowerCase();
@@ -1988,10 +2202,13 @@ function createMCPServer(name, config = {}) {
 }
 __name(createMCPServer, "createMCPServer");
 export {
+  adaptConnectMiddleware,
+  adaptMiddleware,
   buildWidgetUrl,
   createExternalUrlResource,
   createMCPServer,
   createRawHtmlResource,
   createRemoteDomResource,
-  createUIResourceFromDefinition
+  createUIResourceFromDefinition,
+  isExpressMiddleware
 };

package/dist/src/server/logging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/server/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAuCzE"}
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/server/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAE1C;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CA2CzE"}

package/dist/src/server/mcp-server.d.ts

@@ -393,14 +393,16 @@ export declare class McpServer {
      * Unlike `listen()`, this method does not start a server - it only prepares the
      * routes and returns the handler function that can be used with external servers.
      *
+     * @param options - Optional configuration for the handler
+     * @param options.provider - Platform provider (e.g., 'supabase') to handle platform-specific path rewriting
      * @returns Promise that resolves to the fetch handler function
      *
      * @example
      * ```typescript
-     * // For Supabase Edge Functions
+     * // For Supabase Edge Functions (handles path rewriting automatically)
      * const server = createMCPServer('my-server');
      * server.tool({ ... });
-     * const handler = await server.getHandler();
+     * const handler = await server.getHandler({ provider: 'supabase' });
      * Deno.serve(handler);
      * ```
      *
@@ -413,7 +415,9 @@ export declare class McpServer {
      * export default { fetch: handler };
      * ```
      */
-    getHandler(): Promise<(req: Request) => Promise<Response>>;
+    getHandler(options?: {
+        provider?: "supabase" | "cloudflare" | "deno-deploy";
+    }): Promise<(req: Request) => Promise<Response>>;
     /**
      * Mount MCP Inspector UI at /inspector
      *
@@ -551,7 +555,11 @@ export declare class McpServer {
      */
     private parseTemplateUri;
 }
-export type McpServerInstance = Omit<McpServer, keyof HonoType> & HonoType;
+export type McpServerInstance = Omit<McpServer, keyof HonoType> & HonoType & {
+    getHandler: (options?: {
+        provider?: "supabase" | "cloudflare" | "deno-deploy";
+    }) => Promise<(req: Request) => Promise<Response>>;
+};
 /**
  * Create a new MCP server instance
  *

package/dist/src/server/mcp-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../src/server/mcp-server.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mcp-server.d.ts","sourceRoot":"","sources":["../../../src/server/mcp-server.ts"],"names":[],"mappings":"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"}

package/dist/tsup.config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tsup.config.d.ts","sourceRoot":"","sources":["../tsup.config.ts"],"names":[],"mappings":";AAEA,wBA+BG"}
+{"version":3,"file":"tsup.config.d.ts","sourceRoot":"","sources":["../tsup.config.ts"],"names":[],"mappings":";AAEA,wBAkCG"}