@blinkdotnew/dev-sdk 0.0.1 → 2.1.1

package/dist/index.js

@@ -7,6 +7,33 @@ 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) {
@@ -92,6 +119,9 @@ var NoOpStorageAdapter = class {
   }
 };
 function getDefaultStorageAdapter() {
+  if (isDeno) {
+    return new NoOpStorageAdapter();
+  }
   if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
     try {
       localStorage.setItem("__test__", "test");
@@ -103,28 +133,6 @@ 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) {
@@ -391,32 +399,65 @@ var HttpClient = class {
   authUrl = "https://blink.new";
   coreUrl = "https://core.blink.new";
   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;
+  }
   /**
    * Make an authenticated request to the Blink API
    */
   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
     };
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
+    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;
     }
     const requestInit = {
-      method: options.method || "GET",
+      method,
       headers,
       signal: options.signal
     };
-    if (options.body && options.method !== "GET") {
+    if (options.body && method !== "GET") {
       requestInit.body = typeof options.body === "string" ? options.body : JSON.stringify(options.body);
     }
     try {
@@ -570,12 +611,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 = {};
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
+    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;
     }
     try {
       if (typeof XMLHttpRequest !== "undefined" && options.onProgress) {
@@ -676,7 +717,7 @@ var HttpClient = class {
     });
   }
   /**
-   * Stream AI text generation with Vercel AI SDK data stream format
+   * Stream AI text generation - uses Vercel AI SDK's pipeUIMessageStreamToResponse (Data Stream Protocol)
    */
   async streamAiText(prompt, options = {}, onChunk) {
     const url = this.buildUrl(`/api/ai/${this.projectId}/text`);
@@ -684,9 +725,8 @@ var HttpClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
-    }
+    const auth = this.getAuthorizationHeader(url, token);
+    if (auth) headers.Authorization = auth;
     const body = {
       prompt,
       stream: true,
@@ -706,7 +746,7 @@ var HttpClient = class {
       if (!response.body) {
         throw new BlinkNetworkError("No response body for streaming");
       }
-      return this.parseDataStream(response.body, onChunk);
+      return this.parseDataStreamProtocol(response.body, onChunk);
     } catch (error) {
       if (error instanceof BlinkError) {
         throw error;
@@ -731,7 +771,7 @@ var HttpClient = class {
     });
   }
   /**
-   * Stream AI object generation with Vercel AI SDK data stream format
+   * Stream AI object generation - uses Vercel AI SDK's pipeTextStreamToResponse
    */
   async streamAiObject(prompt, options = {}, onPartial) {
     const url = this.buildUrl(`/api/ai/${this.projectId}/object`);
@@ -739,9 +779,8 @@ var HttpClient = class {
     const headers = {
       "Content-Type": "application/json"
     };
-    if (token) {
-      headers.Authorization = `Bearer ${token}`;
-    }
+    const auth = this.getAuthorizationHeader(url, token);
+    if (auth) headers.Authorization = auth;
     const body = {
       prompt,
       stream: true,
@@ -761,7 +800,35 @@ var HttpClient = class {
       if (!response.body) {
         throw new BlinkNetworkError("No response body for streaming");
       }
-      return this.parseDataStream(response.body, void 0, onPartial);
+      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();
+      }
     } catch (error) {
       if (error instanceof BlinkError) {
         throw error;
@@ -956,93 +1023,94 @@ var HttpClient = class {
     }
   }
   /**
-   * Parse Vercel AI SDK data stream format
-   * Handles text chunks (0:"text"), partial objects (2:[...]), and metadata (d:, e:)
+   * Parse Vercel AI SDK v5 Data Stream Protocol (Server-Sent Events)
+   * Supports all event types from the UI Message Stream protocol
    */
-  async parseDataStream(body, onChunk, onPartial) {
+  async parseDataStreamProtocol(body, onChunk) {
     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(/\r?\n/);
+        const lines = buffer.split("\n");
         buffer = lines.pop() || "";
         for (const line of lines) {
           if (!line.trim()) continue;
+          if (line === "[DONE]") {
+            continue;
+          }
+          if (!line.startsWith("data: ")) continue;
           try {
-            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;
+            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);
                 }
-              }
-            } 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);
+                if (part.textDelta) {
+                  finalResult.text += part.textDelta;
+                  if (onChunk) onChunk(part.textDelta);
                 }
-                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;
+                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;
             }
+          } catch (e) {
           }
-        } catch (error) {
-          console.warn("Failed to parse final buffer:", buffer, error);
         }
       }
       return finalResult;
@@ -1933,22 +2001,33 @@ var BlinkAuth = class {
     if (!hasWindow()) {
       throw new BlinkAuthError("NETWORK_ERROR" /* NETWORK_ERROR */, "signInWithProvider requires a browser environment");
     }
+    const shouldPreferRedirect = isWeb && this.isIframe || typeof window !== "undefined" && window.crossOriginIsolated === true;
+    const state = this.generateState();
+    try {
+      const sessionStorage = getSessionStorage();
+      if (sessionStorage) {
+        sessionStorage.setItem("blink_oauth_state", state);
+      }
+    } catch {
+    }
+    const redirectUrl = options?.redirectUrl || getLocationOrigin() || "";
+    const buildAuthUrl = (mode) => {
+      const url = new URL("/auth", this.authUrl);
+      url.searchParams.set("provider", provider);
+      url.searchParams.set("project_id", this.config.projectId);
+      url.searchParams.set("state", state);
+      url.searchParams.set("mode", mode);
+      url.searchParams.set("redirect_url", redirectUrl);
+      url.searchParams.set("opener_origin", getLocationOrigin() || "");
+      return url;
+    };
+    if (shouldPreferRedirect) {
+      window.location.href = buildAuthUrl("redirect").toString();
+      return new Promise(() => {
+      });
+    }
     return new Promise((resolve, reject) => {
-      const state = this.generateState();
-      try {
-        const sessionStorage = getSessionStorage();
-        if (sessionStorage) {
-          sessionStorage.setItem("blink_oauth_state", state);
-        }
-      } catch {
-      }
-      const redirectUrl = options?.redirectUrl || getLocationOrigin() || "";
-      const popupUrl = new URL("/auth", this.authUrl);
-      popupUrl.searchParams.set("provider", provider);
-      popupUrl.searchParams.set("project_id", this.config.projectId);
-      popupUrl.searchParams.set("state", state);
-      popupUrl.searchParams.set("mode", "popup");
-      popupUrl.searchParams.set("redirect_url", redirectUrl);
+      const popupUrl = buildAuthUrl("popup");
       const popup = window.open(
         popupUrl.toString(),
         "blink-auth",
@@ -1959,6 +2038,15 @@ var BlinkAuth = class {
         return;
       }
       let timeoutId;
+      let closedIntervalId;
+      let cleanedUp = false;
+      const cleanup = () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        clearTimeout(timeoutId);
+        if (closedIntervalId) clearInterval(closedIntervalId);
+        window.removeEventListener("message", messageListener);
+      };
       const messageListener = (event) => {
         let allowed = false;
         try {
@@ -1995,29 +2083,34 @@ var BlinkAuth = class {
           }, true).then(() => {
             resolve(this.authState.user);
           }).catch(reject);
-          clearTimeout(timeoutId);
-          window.removeEventListener("message", messageListener);
+          cleanup();
           popup.close();
         } else if (event.data?.type === "BLINK_AUTH_ERROR") {
           const errorCode = this.mapErrorCodeFromResponse(event.data.code);
           reject(new BlinkAuthError(errorCode, event.data.message || "Authentication failed"));
-          clearTimeout(timeoutId);
-          window.removeEventListener("message", messageListener);
+          cleanup();
           popup.close();
         }
       };
+      if (popup.opener === null) {
+        try {
+          popup.close();
+        } catch {
+        }
+        cleanup();
+        window.location.href = buildAuthUrl("redirect").toString();
+        return;
+      }
       timeoutId = setTimeout(() => {
-        window.removeEventListener("message", messageListener);
+        cleanup();
         if (!popup.closed) {
           popup.close();
         }
         reject(new BlinkAuthError("AUTH_TIMEOUT" /* AUTH_TIMEOUT */, "Authentication timed out"));
       }, 3e5);
-      const checkClosed = setInterval(() => {
+      closedIntervalId = setInterval(() => {
         if (popup.closed) {
-          clearInterval(checkClosed);
-          clearTimeout(timeoutId);
-          window.removeEventListener("message", messageListener);
+          cleanup();
           reject(new BlinkAuthError("POPUP_CANCELED" /* POPUP_CANCELED */, "Authentication was canceled"));
         }
       }, 1e3);
@@ -2944,6 +3037,11 @@ 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()}`);
 }
@@ -3162,6 +3260,7 @@ 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;
   }
@@ -3210,6 +3309,7 @@ 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;
   }
@@ -3217,6 +3317,7 @@ 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;
   }
@@ -3279,7 +3380,6 @@ var BlinkStorageImpl = class {
         correctedPath,
         // Use corrected path with proper extension
         {
-          upsert: options.upsert,
           onProgress: options.onProgress,
           contentType: detectedContentType
           // Pass detected content type
@@ -3299,7 +3399,7 @@ var BlinkStorageImpl = class {
       if (error instanceof Error && "status" in error) {
         const status = error.status;
         if (status === 409) {
-          throw new BlinkStorageError("File already exists. Set upsert: true to overwrite.", 409);
+          throw new BlinkStorageError("File already exists.", 409);
         }
         if (status === 400) {
           throw new BlinkStorageError("Invalid request parameters", 400);
@@ -3344,7 +3444,6 @@ var BlinkStorageImpl = class {
         detectedContentType
       };
     } catch (error) {
-      console.warn("File type detection failed, using original path:", error);
       return {
         correctedPath: originalPath,
         detectedContentType: "application/octet-stream"
@@ -3734,13 +3833,7 @@ var BlinkAIImpl = class {
         options.prompt || "",
         requestBody
       );
-      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");
-      }
+      return response.data;
     } catch (error) {
       if (error instanceof BlinkAIError) {
         throw error;
@@ -3809,9 +3902,14 @@ var BlinkAIImpl = class {
       );
       return {
         text: result.text || "",
-        finishReason: "stop",
+        finishReason: result.finishReason || "stop",
         usage: result.usage,
-        ...result
+        toolCalls: result.toolCalls,
+        toolResults: result.toolResults,
+        sources: result.sources,
+        files: result.files,
+        reasoningDetails: result.reasoning,
+        response: result.response
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -3890,13 +3988,7 @@ var BlinkAIImpl = class {
           signal: options.signal
         }
       );
-      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");
-      }
+      return response.data;
     } catch (error) {
       if (error instanceof BlinkAIError) {
         throw error;
@@ -3958,8 +4050,7 @@ var BlinkAIImpl = class {
       return {
         object: result.object || {},
         finishReason: "stop",
-        usage: result.usage,
-        ...result
+        usage: result.usage
       };
     } catch (error) {
       if (error instanceof BlinkAIError) {
@@ -5278,7 +5369,6 @@ 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);
@@ -5488,6 +5578,45 @@ var BlinkConnectorsImpl = class {
   }
 };
 
+// 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;
@@ -5499,8 +5628,12 @@ var BlinkClientImpl = class {
   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,
@@ -5515,6 +5648,11 @@ var BlinkClientImpl = class {
     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);
@@ -5548,8 +5686,10 @@ 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