@blinkdotnew/dev-sdk 2.1.1 → 2.1.2

package/dist/index.js

@@ -7,33 +7,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// ../core/src/platform.ts
-function detectPlatform() {
-  if (typeof Deno !== "undefined") {
-    return "deno";
-  }
-  if (typeof process !== "undefined" && process.versions?.node) {
-    if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-      return "react-native";
-    }
-    return "node";
-  }
-  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-    return "react-native";
-  }
-  if (typeof window !== "undefined" && typeof document !== "undefined") {
-    return "web";
-  }
-  return "node";
-}
-var platform = detectPlatform();
-var isWeb = platform === "web";
-var isReactNative = platform === "react-native";
-var isNode = platform === "node";
-var isDeno = platform === "deno";
-var isBrowser = isWeb || isReactNative;
-var isServer = isNode || isDeno;
-
 // ../core/src/storage-adapter.ts
 var WebStorageAdapter = class {
   getItem(key) {
@@ -119,9 +92,6 @@ var NoOpStorageAdapter = class {
   }
 };
 function getDefaultStorageAdapter() {
-  if (isDeno) {
-    return new NoOpStorageAdapter();
-  }
   if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
     try {
       localStorage.setItem("__test__", "test");
@@ -133,6 +103,28 @@ function getDefaultStorageAdapter() {
   return new NoOpStorageAdapter();
 }
 
+// ../core/src/platform.ts
+function detectPlatform() {
+  if (typeof process !== "undefined" && process.versions?.node) {
+    if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+      return "react-native";
+    }
+    return "node";
+  }
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return "react-native";
+  }
+  if (typeof window !== "undefined" && typeof document !== "undefined") {
+    return "web";
+  }
+  return "node";
+}
+var platform = detectPlatform();
+var isWeb = platform === "web";
+var isReactNative = platform === "react-native";
+var isNode = platform === "node";
+var isBrowser = isWeb || isReactNative;
+
 // ../core/src/types.ts
 var BlinkError = class extends Error {
   constructor(message, code, status, details) {
@@ -396,44 +388,17 @@ function convertKeysToCamelCase(obj) {
   return converted;
 }
 var HttpClient = class {
-  authUrl = "https://blink.new";
-  coreUrl = "https://core.blink.new";
+  authUrl;
+  coreUrl;
   projectId;
-  publishableKey;
-  secretKey;
-  // Permanent, non-expiring key (like Stripe's sk_live_...)
   getToken;
   getValidToken;
   constructor(config, getToken, getValidToken) {
     this.projectId = config.projectId;
-    this.publishableKey = config.publishableKey;
-    this.secretKey = config.secretKey || config.serviceToken;
     this.getToken = getToken;
     this.getValidToken = getValidToken;
-  }
-  shouldAttachPublishableKey(path, method) {
-    if (method !== "GET" && method !== "POST") return false;
-    if (path.includes("/api/analytics/")) return true;
-    if (path.includes("/api/storage/")) return true;
-    if (path.includes("/api/db/") && path.includes("/rest/v1/")) return method === "GET";
-    return false;
-  }
-  shouldSkipSecretKey(url) {
-    try {
-      const parsed = new URL(url);
-      return parsed.hostname.endsWith(".functions.blink.new");
-    } catch {
-      return false;
-    }
-  }
-  getAuthorizationHeader(url, token) {
-    if (this.secretKey && !this.shouldSkipSecretKey(url)) {
-      return `Bearer ${this.secretKey}`;
-    }
-    if (token) {
-      return `Bearer ${token}`;
-    }
-    return null;
+    this.authUrl = config.auth?.authUrl ?? "https://blink.new";
+    this.coreUrl = config.auth?.coreUrl ?? "https://dev.core.blink.new";
   }
   /**
    * Make an authenticated request to the Blink API
@@ -441,23 +406,19 @@ var HttpClient = class {
   async request(path, options = {}) {
     const url = this.buildUrl(path, options.searchParams);
     const token = this.getValidToken ? await this.getValidToken() : this.getToken();
-    const method = options.method || "GET";
     const headers = {
       "Content-Type": "application/json",
       ...options.headers
     };
-    const auth = this.getAuthorizationHeader(url, token);
-    if (auth) {
-      headers.Authorization = auth;
-    } else if (this.publishableKey && !headers["x-blink-publishable-key"] && this.shouldAttachPublishableKey(path, method)) {
-      headers["x-blink-publishable-key"] = this.publishableKey;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
     }
     const requestInit = {
-      method,
+      method: options.method || "GET",
       headers,
       signal: options.signal
     };
-    if (options.body && method !== "GET") {
+    if (options.body && options.method !== "GET") {
       requestInit.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
     }
     try {
@@ -611,12 +572,12 @@ var HttpClient = class {
       throw new BlinkValidationError("Unsupported file type");
     }
     formData.append("path", filePath);
+    if (options.upsert !== void 0) {
+      formData.append("options", JSON.stringify({ upsert: options.upsert }));
+    }
     const headers = {};
-    const auth = this.getAuthorizationHeader(url, token);
-    if (auth) {
-      headers.Authorization = auth;
-    } else if (this.publishableKey && path.includes("/api/storage/") && !headers["x-blink-publishable-key"]) {
-      headers["x-blink-publishable-key"] = this.publishableKey;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
     }
     try {
       if (typeof XMLHttpRequest !== "undefined" && options.onProgress) {
@@ -717,7 +678,7 @@ var HttpClient = class {
     });
   }
   /**
-   * Stream AI text generation - uses Vercel AI SDK's pipeUIMessageStreamToResponse (Data Stream Protocol)
+   * Stream AI text generation with Vercel AI SDK data stream format
    */
   async streamAiText(prompt, options = {}, onChunk) {
     const url = this.buildUrl(`/api/ai/${this.projectId}/text`);
@@ -725,8 +686,9 @@ var HttpClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    const auth = this.getAuthorizationHeader(url, token);
-    if (auth) headers.Authorization = auth;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
     const body = {
       prompt,
       stream: true,
@@ -746,7 +708,7 @@ var HttpClient = class {
       if (!response.body) {
         throw new BlinkNetworkError("No response body for streaming");
       }
-      return this.parseDataStreamProtocol(response.body, onChunk);
+      return this.parseDataStream(response.body, onChunk);
     } catch (error) {
       if (error instanceof BlinkError) {
         throw error;
@@ -771,7 +733,7 @@ var HttpClient = class {
     });
   }
   /**
-   * Stream AI object generation - uses Vercel AI SDK's pipeTextStreamToResponse
+   * Stream AI object generation with Vercel AI SDK data stream format
    */
   async streamAiObject(prompt, options = {}, onPartial) {
     const url = this.buildUrl(`/api/ai/${this.projectId}/object`);
@@ -779,8 +741,9 @@ var HttpClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    const auth = this.getAuthorizationHeader(url, token);
-    if (auth) headers.Authorization = auth;
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
     const body = {
       prompt,
       stream: true,
@@ -800,35 +763,7 @@ var HttpClient = class {
       if (!response.body) {
         throw new BlinkNetworkError("No response body for streaming");
       }
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      let latestObject = {};
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          const chunk = decoder.decode(value, { stream: true });
-          buffer += chunk;
-          try {
-            const parsed = JSON.parse(buffer);
-            latestObject = parsed;
-            if (onPartial) {
-              onPartial(parsed);
-            }
-          } catch {
-          }
-        }
-        if (buffer) {
-          try {
-            latestObject = JSON.parse(buffer);
-          } catch {
-          }
-        }
-        return { object: latestObject };
-      } finally {
-        reader.releaseLock();
-      }
+      return this.parseDataStream(response.body, void 0, onPartial);
     } catch (error) {
       if (error instanceof BlinkError) {
         throw error;
@@ -926,38 +861,6 @@ var HttpClient = class {
   async dataSearch(projectId, request) {
     return this.post(`/api/data/${projectId}/search`, request);
   }
-  /**
-   * Connector requests
-   */
-  formatProviderForPath(provider) {
-    return provider.replace("_", "-");
-  }
-  async connectorStatus(provider) {
-    return this.request(`/api/connectors/${this.formatProviderForPath(provider)}/${this.projectId}/status`, {
-      method: "GET"
-    });
-  }
-  async connectorExecute(provider, request) {
-    const path = request.method.startsWith("/") ? request.method : `/${request.method}`;
-    const url = `/api/connectors/${this.formatProviderForPath(provider)}/${this.projectId}${path}`;
-    const method = (request.http_method || "GET").toUpperCase();
-    if (method === "GET") {
-      return this.request(url, {
-        method: "GET",
-        searchParams: request.params
-      });
-    }
-    return this.request(url, {
-      method,
-      body: request.params || {}
-    });
-  }
-  async connectorSaveApiKey(provider, request) {
-    return this.request(`/api/connectors/${this.formatProviderForPath(provider)}/${this.projectId}/api-key`, {
-      method: "POST",
-      body: request
-    });
-  }
   /**
    * Realtime-specific requests
    */
@@ -1023,94 +926,93 @@ var HttpClient = class {
     }
   }
   /**
-   * Parse Vercel AI SDK v5 Data Stream Protocol (Server-Sent Events)
-   * Supports all event types from the UI Message Stream protocol
+   * Parse Vercel AI SDK data stream format
+   * Handles text chunks (0:"text"), partial objects (2:[...]), and metadata (d:, e:)
    */
-  async parseDataStreamProtocol(body, onChunk) {
+  async parseDataStream(body, onChunk, onPartial) {
     const reader = body.getReader();
     const decoder = new TextDecoder();
-    const finalResult = {
-      text: "",
-      toolCalls: [],
-      toolResults: [],
-      sources: [],
-      files: [],
-      reasoning: []
-    };
     let buffer = "";
+    let finalResult = {};
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) break;
         buffer += decoder.decode(value, { stream: true });
-        const lines = buffer.split("\n");
+        const lines = buffer.split(/\r?\n/);
         buffer = lines.pop() || "";
         for (const line of lines) {
           if (!line.trim()) continue;
-          if (line === "[DONE]") {
-            continue;
-          }
-          if (!line.startsWith("data: ")) continue;
           try {
-            const jsonStr = line.slice(6);
-            const part = JSON.parse(jsonStr);
-            switch (part.type) {
-              case "text-start":
-                break;
-              case "text-delta":
-                if (part.delta) {
-                  finalResult.text += part.delta;
-                  if (onChunk) onChunk(part.delta);
+            if (line.startsWith("f:")) {
+              const metadata = JSON.parse(line.slice(2));
+              finalResult.messageId = metadata.messageId;
+            } else if (line.startsWith("0:")) {
+              const textChunk = JSON.parse(line.slice(2));
+              if (onChunk) {
+                onChunk(textChunk);
+              }
+              finalResult.text = (finalResult.text || "") + textChunk;
+            } else if (line.startsWith("2:")) {
+              const data = JSON.parse(line.slice(2));
+              if (Array.isArray(data) && data.length > 0) {
+                const item = data[0];
+                if (typeof item === "string") {
+                  finalResult.status = item;
+                } else if (typeof item === "object") {
+                  if (onPartial) {
+                    onPartial(item);
+                  }
+                  finalResult.object = item;
                 }
-                if (part.textDelta) {
-                  finalResult.text += part.textDelta;
-                  if (onChunk) onChunk(part.textDelta);
+              }
+            } else if (line.startsWith("d:")) {
+              const metadata = JSON.parse(line.slice(2));
+              if (metadata.usage) {
+                finalResult.usage = metadata.usage;
+              }
+              if (metadata.finishReason) {
+                finalResult.finishReason = metadata.finishReason;
+              }
+            } else if (line.startsWith("e:")) {
+              const errorData = JSON.parse(line.slice(2));
+              finalResult.error = errorData;
+            }
+          } catch (error) {
+            console.warn("Failed to parse stream line:", line, error);
+          }
+        }
+      }
+      if (buffer.trim()) {
+        try {
+          if (buffer.startsWith("0:")) {
+            const textChunk = JSON.parse(buffer.slice(2));
+            if (onChunk) {
+              onChunk(textChunk);
+            }
+            finalResult.text = (finalResult.text || "") + textChunk;
+          } else if (buffer.startsWith("2:")) {
+            const data = JSON.parse(buffer.slice(2));
+            if (Array.isArray(data) && data.length > 0) {
+              const item = data[0];
+              if (typeof item === "object") {
+                if (onPartial) {
+                  onPartial(item);
                 }
-                break;
-              case "text-end":
-                break;
-              case "tool-call":
-                finalResult.toolCalls.push({
-                  toolCallId: part.toolCallId,
-                  toolName: part.toolName,
-                  args: part.args
-                });
-                break;
-              case "tool-result":
-                finalResult.toolResults.push({
-                  toolCallId: part.toolCallId,
-                  toolName: part.toolName,
-                  result: part.result
-                });
-                break;
-              case "source-url":
-                finalResult.sources.push({
-                  id: part.id,
-                  url: part.url,
-                  title: part.title
-                });
-                break;
-              case "file":
-                finalResult.files.push(part.file);
-                break;
-              case "reasoning":
-                finalResult.reasoning.push(part.content);
-                break;
-              case "finish":
-                finalResult.finishReason = part.finishReason;
-                finalResult.usage = part.usage;
-                if (part.response) finalResult.response = part.response;
-                break;
-              case "error":
-                finalResult.error = part.error;
-                throw new Error(part.error);
-              case "data":
-                if (!finalResult.customData) finalResult.customData = [];
-                finalResult.customData.push(part.value);
-                break;
+                finalResult.object = item;
+              }
+            }
+          } else if (buffer.startsWith("d:")) {
+            const metadata = JSON.parse(buffer.slice(2));
+            if (metadata.usage) {
+              finalResult.usage = metadata.usage;
+            }
+            if (metadata.finishReason) {
+              finalResult.finishReason = metadata.finishReason;
             }
-          } catch (e) {
           }
+        } catch (error) {
+          console.warn("Failed to parse final buffer:", buffer, error);
         }
       }
       return finalResult;
@@ -1278,13 +1180,13 @@ var BlinkAuth = class {
       mode: "managed",
       // Default mode
       authUrl: "https://blink.new",
-      coreUrl: "https://core.blink.new",
+      coreUrl: "https://dev.core.blink.new",
       detectSessionInUrl: true,
       // Default to true for web compatibility
       ...config.auth
     };
     this.authUrl = this.authConfig.authUrl || "https://blink.new";
-    this.coreUrl = this.authConfig.coreUrl || "https://core.blink.new";
+    this.coreUrl = this.authConfig.coreUrl || "https://dev.core.blink.new";
     const hostname = getLocationHostname();
     if (hostname && this.authUrl === "https://blink.new" && (hostname === "localhost" || hostname === "127.0.0.1")) {
       console.warn("\u26A0\uFE0F Using default authUrl in development. Set auth.authUrl to your app origin for headless auth endpoints to work.");
@@ -3037,11 +2939,6 @@ var BlinkAuth = class {
 };
 
 // src/database.ts
-function assertServerOnly(methodName) {
-  if (typeof window !== "undefined") {
-    throw new Error(`${methodName} is server-only. Use Blink CRUD methods (blink.db.<table>.*) instead.`);
-  }
-}
 function camelToSnake3(str) {
   return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 }
@@ -3260,7 +3157,6 @@ var BlinkTable = class {
    * Raw SQL query on this table (for advanced use cases)
    */
   async sql(query, params) {
-    assertServerOnly("blink.db.<table>.sql");
     const response = await this.httpClient.dbSql(query, params);
     return response.data;
   }
@@ -3309,7 +3205,6 @@ var BlinkDatabase = class {
    * Execute raw SQL query
    */
   async sql(query, params) {
-    assertServerOnly("blink.db.sql");
     const response = await this.httpClient.dbSql(query, params);
     return response.data;
   }
@@ -3317,7 +3212,6 @@ var BlinkDatabase = class {
    * Execute batch SQL operations
    */
   async batch(statements, mode = "write") {
-    assertServerOnly("blink.db.batch");
     const response = await this.httpClient.dbBatch(statements, mode);
     return response.data;
   }
@@ -3380,6 +3274,7 @@ var BlinkStorageImpl = class {
         correctedPath,
         // Use corrected path with proper extension
         {
+          upsert: options.upsert,
           onProgress: options.onProgress,
           contentType: detectedContentType
           // Pass detected content type
@@ -3399,7 +3294,7 @@ var BlinkStorageImpl = class {
       if (error instanceof Error && "status" in error) {
         const status = error.status;
         if (status === 409) {
-          throw new BlinkStorageError("File already exists.", 409);
+          throw new BlinkStorageError("File already exists. Set upsert: true to overwrite.", 409);
         }
         if (status === 400) {
           throw new BlinkStorageError("Invalid request parameters", 400);
@@ -3444,6 +3339,7 @@ var BlinkStorageImpl = class {
         detectedContentType
       };
     } catch (error) {
+      console.warn("File type detection failed, using original path:", error);
       return {
         correctedPath: originalPath,
         detectedContentType: "application/octet-stream"
@@ -3833,7 +3729,13 @@ var BlinkAIImpl = class {
         options.prompt || "",
         requestBody
       );
-      return response.data;
+      if (response.data?.result) {
+        return response.data.result;
+      } else if (response.data?.text) {
+        return response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing text");
+      }
     } catch (error) {
       if (error instanceof BlinkAIError) {
         throw error;
@@ -3902,14 +3804,9 @@ var BlinkAIImpl = class {
       );
       return {
         text: result.text || "",
-        finishReason: result.finishReason || "stop",
+        finishReason: "stop",
         usage: result.usage,
-        toolCalls: result.toolCalls,
-        toolResults: result.toolResults,
-        sources: result.sources,
-        files: result.files,
-        reasoningDetails: result.reasoning,
-        response: result.response
+        ...result
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -3988,7 +3885,13 @@ var BlinkAIImpl = class {
           signal: options.signal
         }
       );
-      return response.data;
+      if (response.data?.result) {
+        return response.data.result;
+      } else if (response.data?.object) {
+        return response.data;
+      } else {
+        throw new BlinkAIError("Invalid response format: missing object");
+      }
     } catch (error) {
       if (error instanceof BlinkAIError) {
         throw error;
@@ -4050,7 +3953,8 @@ var BlinkAIImpl = class {
       return {
         object: result.object || {},
         finishReason: "stop",
-        usage: result.usage
+        usage: result.usage,
+        ...result
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -4900,7 +4804,7 @@ var BlinkRealtimeChannel = class {
     return new Promise((resolve, reject) => {
       try {
         const httpClient = this.httpClient;
-        const coreUrl = httpClient.coreUrl || "https://core.blink.new";
+        const coreUrl = httpClient.coreUrl || "https://dev.core.blink.new";
         const baseUrl = coreUrl.replace("https://", "wss://").replace("http://", "ws://");
         const wsUrl = `${baseUrl}?project_id=${this.projectId}`;
         console.log(`\u{1F517} Attempting WebSocket connection to: ${wsUrl}`);
@@ -5369,6 +5273,7 @@ var BlinkAnalyticsImpl = class {
     } catch (error) {
       this.queue = [...events, ...this.queue];
       this.persistQueue();
+      console.error("Failed to send analytics events:", error);
     }
     if (this.queue.length > 0) {
       this.timer = setTimeout(() => this.flush(), BATCH_TIMEOUT);
@@ -5559,64 +5464,6 @@ var BlinkAnalyticsImpl = class {
   }
 };
 
-// src/connectors.ts
-var BlinkConnectorsImpl = class {
-  constructor(httpClient) {
-    this.httpClient = httpClient;
-  }
-  async status(provider, options) {
-    const response = await this.httpClient.connectorStatus(provider);
-    return response.data;
-  }
-  async execute(provider, request) {
-    const response = await this.httpClient.connectorExecute(provider, request);
-    return response.data;
-  }
-  async saveApiKey(provider, request) {
-    const response = await this.httpClient.connectorSaveApiKey(provider, request);
-    return response.data;
-  }
-};
-
-// src/functions.ts
-var BlinkFunctionsImpl = class {
-  httpClient;
-  projectId;
-  constructor(httpClient, projectId, _getToken) {
-    this.httpClient = httpClient;
-    this.projectId = projectId;
-  }
-  /**
-   * Get the project suffix from the full project ID.
-   * Project IDs are formatted as: prj_xxxxx
-   * The suffix is the last 8 characters used in function URLs.
-   */
-  getProjectSuffix() {
-    return this.projectId.slice(-8);
-  }
-  /**
-   * Build the full function URL
-   */
-  buildFunctionUrl(functionSlug, searchParams) {
-    const suffix = this.getProjectSuffix();
-    const baseUrl = `https://${suffix}--${functionSlug}.functions.blink.new`;
-    if (!searchParams || Object.keys(searchParams).length === 0) {
-      return baseUrl;
-    }
-    const url = new URL(baseUrl);
-    Object.entries(searchParams).forEach(([key, value]) => {
-      url.searchParams.set(key, value);
-    });
-    return url.toString();
-  }
-  async invoke(functionSlug, options = {}) {
-    const { method = "POST", body, headers = {}, searchParams } = options;
-    const url = this.buildFunctionUrl(functionSlug, searchParams);
-    const res = await this.httpClient.request(url, { method, body, headers });
-    return { data: res.data, status: res.status, headers: res.headers };
-  }
-};
-
 // src/client.ts
 var BlinkClientImpl = class {
   auth;
@@ -5627,13 +5474,8 @@ var BlinkClientImpl = class {
   realtime;
   notifications;
   analytics;
-  connectors;
-  functions;
   httpClient;
   constructor(config) {
-    if ((config.secretKey || config.serviceToken) && isBrowser) {
-      throw new Error("secretKey/serviceToken is server-only. Do not provide it in browser/React Native clients.");
-    }
     this.auth = new BlinkAuth(config);
     this.httpClient = new HttpClient(
       config,
@@ -5647,12 +5489,6 @@ var BlinkClientImpl = class {
     this.realtime = new BlinkRealtimeImpl(this.httpClient, config.projectId);
     this.notifications = new BlinkNotificationsImpl(this.httpClient);
     this.analytics = new BlinkAnalyticsImpl(this.httpClient, config.projectId);
-    this.connectors = new BlinkConnectorsImpl(this.httpClient);
-    this.functions = new BlinkFunctionsImpl(
-      this.httpClient,
-      config.projectId,
-      () => this.auth.getValidToken()
-    );
     this.auth.onAuthStateChanged((state) => {
       if (state.isAuthenticated && state.user) {
         this.analytics.setUserId(state.user.id);
@@ -5674,7 +5510,6 @@ function createClient(config) {
 exports.AsyncStorageAdapter = AsyncStorageAdapter;
 exports.BlinkAIImpl = BlinkAIImpl;
 exports.BlinkAnalyticsImpl = BlinkAnalyticsImpl;
-exports.BlinkConnectorsImpl = BlinkConnectorsImpl;
 exports.BlinkDataImpl = BlinkDataImpl;
 exports.BlinkDatabase = BlinkDatabase;
 exports.BlinkRealtimeChannel = BlinkRealtimeChannel;
@@ -5686,10 +5521,8 @@ exports.WebStorageAdapter = WebStorageAdapter;
 exports.createClient = createClient;
 exports.getDefaultStorageAdapter = getDefaultStorageAdapter;
 exports.isBrowser = isBrowser;
-exports.isDeno = isDeno;
 exports.isNode = isNode;
 exports.isReactNative = isReactNative;
-exports.isServer = isServer;
 exports.isWeb = isWeb;
 exports.platform = platform;
 //# sourceMappingURL=index.js.map