instavm 0.1.0

package/dist/index.mjs

@@ -0,0 +1,935 @@
+"use strict";
+
+// src/client/HTTPClient.ts
+import axios from "axios";
+
+// src/errors/BaseError.ts
+var InstaVMError = class extends Error {
+  constructor(message, options) {
+    super(message);
+    this.name = this.constructor.name;
+    this.code = options?.code;
+    this.statusCode = options?.statusCode;
+    this.response = options?.response;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var AuthenticationError = class extends InstaVMError {
+  constructor(message = "Authentication failed", options) {
+    super(message, { ...options, statusCode: 401 });
+  }
+};
+var RateLimitError = class extends InstaVMError {
+  constructor(message = "Rate limit exceeded", retryAfter, options) {
+    super(message, { ...options, statusCode: 429 });
+    this.retryAfter = retryAfter;
+  }
+};
+var QuotaExceededError = class extends InstaVMError {
+  constructor(message = "Usage quota exceeded", options) {
+    super(message, { ...options, statusCode: 402 });
+  }
+};
+var NetworkError = class extends InstaVMError {
+  constructor(message = "Network error", options) {
+    super(message, options);
+  }
+};
+var ExecutionError = class extends InstaVMError {
+  constructor(message, executionOutput, executionTime, options) {
+    super(message, options);
+    this.executionOutput = executionOutput;
+    this.executionTime = executionTime;
+  }
+};
+var SessionError = class extends InstaVMError {
+  constructor(message = "Session error", options) {
+    super(message, options);
+  }
+};
+var BrowserError = class extends InstaVMError {
+  constructor(message = "Browser error", options) {
+    super(message, options);
+  }
+};
+var BrowserSessionError = class extends BrowserError {
+  constructor(message = "Browser session error", options) {
+    super(message, options);
+  }
+};
+var BrowserInteractionError = class extends BrowserError {
+  constructor(message = "Browser interaction error", options) {
+    super(message, options);
+  }
+};
+var BrowserTimeoutError = class extends BrowserError {
+  constructor(message = "Browser operation timed out", options) {
+    super(message, options);
+  }
+};
+var BrowserNavigationError = class extends BrowserError {
+  constructor(message = "Browser navigation error", options) {
+    super(message, options);
+  }
+};
+var ElementNotFoundError = class extends BrowserError {
+  constructor(message = "Element not found", selector, options) {
+    super(message, options);
+    this.selector = selector;
+  }
+};
+
+// src/utils/retry.ts
+function defaultRetryCondition(error) {
+  if (error instanceof NetworkError) return true;
+  if (error instanceof RateLimitError) return true;
+  if (error.response?.status >= 500) return true;
+  if (error.code === "ECONNABORTED" || error.code === "ETIMEDOUT") return true;
+  if (error.code === "ECONNRESET" || error.code === "ENOTFOUND") return true;
+  return false;
+}
+function calculateRetryDelay(attempt, baseDelay, maxDelay = 3e4) {
+  const exponentialDelay = baseDelay * Math.pow(2, attempt - 1);
+  const jitteredDelay = exponentialDelay * (0.5 + Math.random() * 0.5);
+  return Math.min(jitteredDelay, maxDelay);
+}
+async function withRetry(fn, options) {
+  const {
+    retries,
+    retryDelay,
+    maxRetryDelay = 3e4,
+    retryCondition = defaultRetryCondition
+  } = options;
+  let lastError;
+  for (let attempt = 1; attempt <= retries + 1; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === retries + 1) {
+        break;
+      }
+      if (!retryCondition(error)) {
+        break;
+      }
+      const delay = calculateRetryDelay(attempt, retryDelay, maxRetryDelay);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+  throw lastError;
+}
+
+// src/client/HTTPClient.ts
+var HTTPClient = class {
+  get apiKey() {
+    return this.config.apiKey;
+  }
+  constructor(config) {
+    this.config = config;
+    this.client = axios.create({
+      baseURL: config.baseURL,
+      timeout: config.timeout,
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "instavm-js-sdk/0.1.0"
+      }
+    });
+    this.setupInterceptors();
+  }
+  setupInterceptors() {
+    this.client.interceptors.request.use(
+      (config) => {
+        if (config.url?.includes("/browser/")) {
+          config.headers["X-API-Key"] = this.config.apiKey;
+        }
+        return config;
+      },
+      (error) => Promise.reject(error)
+    );
+    this.client.interceptors.response.use(
+      (response) => response,
+      (error) => {
+        const axiosError = error;
+        const status = axiosError.response?.status;
+        const data = axiosError.response?.data;
+        const message = data?.message || data?.error || axiosError.message;
+        switch (status) {
+          case 401:
+            throw new AuthenticationError(message, {
+              statusCode: status,
+              response: data
+            });
+          case 402:
+            throw new QuotaExceededError(message, {
+              statusCode: status,
+              response: data
+            });
+          case 429:
+            const retryAfter = parseInt(
+              axiosError.response?.headers["retry-after"] || "60"
+            );
+            throw new RateLimitError(message, retryAfter, {
+              statusCode: status,
+              response: data
+            });
+          case 500:
+          case 502:
+          case 503:
+          case 504:
+            throw new NetworkError(message, {
+              statusCode: status,
+              response: data
+            });
+          default:
+            if (axiosError.code === "ECONNABORTED") {
+              throw new NetworkError("Request timeout", {
+                code: axiosError.code
+              });
+            }
+            throw new InstaVMError(message, {
+              statusCode: status,
+              response: data,
+              code: axiosError.code
+            });
+        }
+      }
+    );
+  }
+  /**
+   * Make an HTTP request with retry logic
+   */
+  async request(requestConfig) {
+    const axiosConfig = {
+      method: requestConfig.method,
+      url: requestConfig.url,
+      headers: requestConfig.headers,
+      data: requestConfig.data,
+      params: requestConfig.params,
+      timeout: requestConfig.timeout || this.config.timeout
+    };
+    const makeRequest = async () => {
+      const response = await this.client.request(axiosConfig);
+      return response.data;
+    };
+    return withRetry(makeRequest, {
+      retries: this.config.maxRetries,
+      retryDelay: this.config.retryDelay
+    });
+  }
+  /**
+   * POST request with JSON body
+   */
+  async post(url, data, headers) {
+    return this.request({
+      method: "POST",
+      url,
+      data,
+      headers
+    });
+  }
+  /**
+   * POST request for code execution (uses X-API-Key header like Python client)
+   */
+  async postExecution(url, data, headers) {
+    const requestHeaders = {
+      "X-API-Key": this.config.apiKey,
+      ...headers
+    };
+    return this.request({
+      method: "POST",
+      url,
+      data,
+      headers: requestHeaders
+    });
+  }
+  /**
+   * POST request with form data (for file uploads)
+   */
+  async postFormData(url, formData, headers) {
+    const requestHeaders = {
+      ...formData.getHeaders(),
+      ...headers
+    };
+    return this.request({
+      method: "POST",
+      url,
+      data: formData,
+      headers: requestHeaders
+    });
+  }
+  /**
+   * GET request
+   */
+  async get(url, params, headers) {
+    return this.request({
+      method: "GET",
+      url,
+      params,
+      headers
+    });
+  }
+  /**
+   * DELETE request
+   */
+  async delete(url, headers) {
+    return this.request({
+      method: "DELETE",
+      url,
+      headers
+    });
+  }
+};
+
+// src/client/BrowserSession.ts
+import { EventEmitter } from "eventemitter3";
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var BrowserSession = class extends EventEmitter {
+  constructor(sessionId, httpClient) {
+    super();
+    this._isActive = true;
+    this.sessionId = sessionId;
+    this.httpClient = httpClient;
+  }
+  /**
+   * Navigate to a URL
+   */
+  async navigate(url, options = {}) {
+    this.ensureActive();
+    const requestData = {
+      url,
+      session_id: this.sessionId,
+      wait_timeout: options.waitTimeout || 3e4,
+      wait_until: options.waitUntil || "load"
+    };
+    try {
+      const response = await this.httpClient.post(
+        "/v1/browser/interactions/navigate",
+        requestData
+      );
+      const result = {
+        success: response.success !== false,
+        url: response.url || url,
+        title: response.title,
+        status: response.status
+      };
+      this.emit("navigation", result);
+      return result;
+    } catch (error) {
+      const navigationError = new BrowserNavigationError(
+        `Navigation failed: ${getErrorMessage(error)}`,
+        { cause: error }
+      );
+      this.emit("error", navigationError);
+      throw navigationError;
+    }
+  }
+  /**
+   * Click an element
+   */
+  async click(selector, options = {}) {
+    this.ensureActive();
+    const requestData = {
+      selector,
+      session_id: this.sessionId,
+      timeout: options.timeout || 1e4,
+      button: options.button || "left",
+      click_count: options.clickCount || 1,
+      force: options.force || false
+    };
+    try {
+      await this.httpClient.post(
+        "/v1/browser/interactions/click",
+        requestData
+      );
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("not found") || errorMessage.includes("selector")) {
+        throw new ElementNotFoundError(
+          `Element not found: ${selector}`,
+          selector,
+          { cause: error }
+        );
+      }
+      if (errorMessage.includes("timeout")) {
+        throw new BrowserTimeoutError(
+          `Click timeout: ${selector}`,
+          { cause: error }
+        );
+      }
+      throw new BrowserInteractionError(
+        `Click failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Type text into an element
+   */
+  async type(selector, text, options = {}) {
+    this.ensureActive();
+    const requestData = {
+      selector,
+      text,
+      session_id: this.sessionId,
+      timeout: options.timeout || 1e4,
+      delay: options.delay || 0,
+      clear: options.clear !== false
+    };
+    try {
+      await this.httpClient.post(
+        "/v1/browser/interactions/type",
+        requestData
+      );
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("not found") || errorMessage.includes("selector")) {
+        throw new ElementNotFoundError(
+          `Element not found: ${selector}`,
+          selector,
+          { cause: error }
+        );
+      }
+      throw new BrowserInteractionError(
+        `Type failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Fill a form field
+   */
+  async fill(selector, value, options = {}) {
+    this.ensureActive();
+    const requestData = {
+      selector,
+      value,
+      session_id: this.sessionId,
+      timeout: options.timeout || 1e4,
+      force: options.force || false
+    };
+    try {
+      await this.httpClient.post(
+        "/v1/browser/interactions/fill",
+        requestData
+      );
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("not found") || errorMessage.includes("selector")) {
+        throw new ElementNotFoundError(
+          `Element not found: ${selector}`,
+          selector,
+          { cause: error }
+        );
+      }
+      throw new BrowserInteractionError(
+        `Fill failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Scroll the page
+   */
+  async scroll(options = {}) {
+    this.ensureActive();
+    const requestData = {
+      session_id: this.sessionId,
+      x: options.x || 0,
+      y: options.y || 500,
+      behavior: options.behavior || "auto"
+    };
+    try {
+      await this.httpClient.post(
+        "/v1/browser/interactions/scroll",
+        requestData
+      );
+    } catch (error) {
+      throw new BrowserInteractionError(
+        `Scroll failed: ${getErrorMessage(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Take a screenshot
+   */
+  async screenshot(options = {}) {
+    this.ensureActive();
+    const requestData = {
+      session_id: this.sessionId,
+      full_page: options.fullPage !== false,
+      format: options.format || "png",
+      quality: options.quality || 90,
+      clip: options.clip
+    };
+    try {
+      const response = await this.httpClient.post(
+        "/v1/browser/interactions/screenshot",
+        requestData
+      );
+      if (!response.screenshot) {
+        throw new BrowserError("Screenshot data not returned");
+      }
+      return response.screenshot;
+    } catch (error) {
+      throw new BrowserInteractionError(
+        `Screenshot failed: ${getErrorMessage(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Extract elements from the page
+   */
+  async extractElements(selector, attributes = ["text"], options = {}) {
+    this.ensureActive();
+    const requestData = {
+      selector,
+      attributes,
+      session_id: this.sessionId,
+      max_results: options.maxResults || 100
+    };
+    try {
+      const response = await this.httpClient.post(
+        "/v1/browser/interactions/extract",
+        requestData
+      );
+      return response.elements || [];
+    } catch (error) {
+      throw new BrowserInteractionError(
+        `Element extraction failed: ${getErrorMessage(error)}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Wait for a condition
+   */
+  async wait(condition, timeout = 1e4) {
+    this.ensureActive();
+    let requestData = {
+      session_id: this.sessionId,
+      timeout
+    };
+    if (condition.type === "timeout") {
+      await new Promise((resolve) => setTimeout(resolve, condition.ms));
+      return;
+    }
+    requestData = {
+      ...requestData,
+      condition: condition.type,
+      selector: "selector" in condition ? condition.selector : void 0
+    };
+    try {
+      await this.httpClient.post(
+        "/v1/browser/interactions/wait",
+        requestData
+      );
+    } catch (error) {
+      const errorMessage = getErrorMessage(error);
+      if (errorMessage.includes("timeout")) {
+        throw new BrowserTimeoutError(
+          `Wait condition timeout: ${condition.type}`,
+          { cause: error }
+        );
+      }
+      throw new BrowserInteractionError(
+        `Wait failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Close the browser session
+   */
+  async close() {
+    if (!this._isActive) {
+      return;
+    }
+    try {
+      await this.httpClient.delete(`/v1/browser/sessions/${this.sessionId}`);
+    } catch (error) {
+      console.warn(`Failed to close browser session ${this.sessionId}:`, getErrorMessage(error));
+    } finally {
+      this._isActive = false;
+      this.emit("close");
+    }
+  }
+  /**
+   * Check if session is active
+   */
+  get isActive() {
+    return this._isActive;
+  }
+  /**
+   * Ensure session is active before operations
+   */
+  ensureActive() {
+    if (!this._isActive) {
+      throw new BrowserError("Browser session is not active");
+    }
+  }
+};
+
+// src/client/BrowserManager.ts
+var BrowserManager = class {
+  constructor(httpClient) {
+    this.activeSessions = /* @__PURE__ */ new Map();
+    this.httpClient = httpClient;
+  }
+  /**
+   * Create a new browser session
+   */
+  async createSession(options = {}) {
+    const requestData = {
+      viewport_width: options.viewportWidth || 1920,
+      viewport_height: options.viewportHeight || 1080,
+      user_agent: options.userAgent
+    };
+    try {
+      const response = await this.httpClient.post(
+        "/v1/browser/sessions/",
+        requestData
+      );
+      if (!response.session_id) {
+        throw new BrowserSessionError("No session ID returned from server");
+      }
+      const session = new BrowserSession(response.session_id, this.httpClient);
+      this.activeSessions.set(response.session_id, session);
+      session.on("close", () => {
+        this.activeSessions.delete(response.session_id);
+      });
+      return session;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new BrowserSessionError(
+        `Failed to create browser session: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Get information about a specific session
+   */
+  async getSession(sessionId) {
+    try {
+      const response = await this.httpClient.get(
+        `/v1/browser/sessions/${sessionId}`
+      );
+      return {
+        sessionId: response.session_id,
+        status: response.status || "active",
+        createdAt: response.created_at,
+        viewportWidth: response.viewport_width,
+        viewportHeight: response.viewport_height,
+        userAgent: response.user_agent
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new BrowserSessionError(
+        `Failed to get session info: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * List all browser sessions
+   */
+  async listSessions() {
+    try {
+      const response = await this.httpClient.get("/v1/browser/sessions/");
+      if (!Array.isArray(response.sessions)) {
+        return [];
+      }
+      return response.sessions.map((session) => ({
+        sessionId: session.session_id,
+        status: session.status || "active",
+        createdAt: session.created_at,
+        viewportWidth: session.viewport_width,
+        viewportHeight: session.viewport_height,
+        userAgent: session.user_agent
+      }));
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new BrowserSessionError(
+        `Failed to list sessions: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Get a locally tracked session
+   */
+  getLocalSession(sessionId) {
+    return this.activeSessions.get(sessionId);
+  }
+  /**
+   * Get all locally tracked sessions
+   */
+  getLocalSessions() {
+    return Array.from(this.activeSessions.values());
+  }
+  /**
+   * Close all active sessions
+   */
+  async closeAllSessions() {
+    const sessions = Array.from(this.activeSessions.values());
+    await Promise.allSettled(
+      sessions.map((session) => session.close())
+    );
+    this.activeSessions.clear();
+  }
+  /**
+   * Clean up resources
+   */
+  async dispose() {
+    await this.closeAllSessions();
+  }
+};
+
+// src/client/InstaVM.ts
+import FormData from "form-data";
+var InstaVM = class {
+  constructor(apiKey, options = {}) {
+    this._sessionId = null;
+    if (!apiKey) {
+      throw new Error("API key is required");
+    }
+    const config = {
+      baseURL: options.baseURL || "https://api.instavm.io",
+      timeout: options.timeout || 3e5,
+      // 5 minutes
+      maxRetries: options.maxRetries || 3,
+      retryDelay: options.retryDelay || 1e3,
+      apiKey
+    };
+    this.httpClient = new HTTPClient(config);
+    this.browser = new BrowserManager(this.httpClient);
+  }
+  /**
+   * Execute code synchronously
+   */
+  async execute(command, options = {}) {
+    let sessionId = options.sessionId || this._sessionId;
+    if (!sessionId) {
+      sessionId = await this.createSession();
+    }
+    const requestData = {
+      command,
+      language: options.language || "python",
+      timeout: options.timeout || 15,
+      session_id: sessionId
+    };
+    try {
+      const response = await this.httpClient.postExecution(
+        "/execute",
+        requestData
+      );
+      if (response.session_id) {
+        this._sessionId = response.session_id;
+      }
+      return {
+        output: response.stdout || response.output || "",
+        success: response.success !== false,
+        executionTime: response.execution_time || 0,
+        sessionId: response.session_id,
+        error: response.error
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new ExecutionError(
+        `Code execution failed: ${errorMessage}`,
+        void 0,
+        void 0,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Execute code asynchronously
+   */
+  async executeAsync(command, options = {}) {
+    let sessionId = options.sessionId || this._sessionId;
+    if (!sessionId) {
+      sessionId = await this.createSession();
+    }
+    const requestData = {
+      command,
+      language: options.language || "python",
+      timeout: options.timeout || 15,
+      session_id: sessionId
+    };
+    try {
+      const response = await this.httpClient.postExecution(
+        "/execute_async",
+        requestData
+      );
+      if (response.session_id) {
+        this._sessionId = response.session_id;
+      }
+      return {
+        taskId: response.task_id,
+        status: response.status || "pending",
+        output: response.stdout || response.output,
+        success: response.success,
+        executionTime: response.execution_time,
+        sessionId: response.session_id,
+        error: response.error
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new ExecutionError(
+        `Async code execution failed: ${errorMessage}`,
+        void 0,
+        void 0,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Upload files to the execution environment
+   */
+  async upload(files, options = {}) {
+    const formData = new FormData();
+    for (const file of files) {
+      if (Buffer.isBuffer(file.content)) {
+        formData.append("files", file.content, file.name);
+      } else {
+        formData.append("files", Buffer.from(file.content), file.name);
+      }
+      if (file.path) {
+        formData.append("paths", file.path);
+      }
+    }
+    if (options.sessionId || this._sessionId) {
+      formData.append("session_id", options.sessionId || this._sessionId);
+    }
+    if (options.remotePath) {
+      formData.append("remote_path", options.remotePath);
+    }
+    if (options.recursive !== void 0) {
+      formData.append("recursive", String(options.recursive));
+    }
+    try {
+      const response = await this.httpClient.postFormData(
+        "/upload",
+        formData
+      );
+      return {
+        success: response.success !== false,
+        files: response.files || [],
+        message: response.message
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new SessionError(
+        `File upload failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Create a new execution session
+   */
+  async createSession() {
+    try {
+      const response = await this.httpClient.post("/v1/sessions/session", {
+        api_key: this.httpClient.apiKey
+      });
+      if (response.session_id) {
+        this._sessionId = response.session_id;
+        return response.session_id;
+      }
+      throw new SessionError("Session creation failed: No session ID returned");
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new SessionError(
+        `Session creation failed: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Close a session
+   */
+  async closeSession(sessionId) {
+    const targetSessionId = sessionId || this._sessionId;
+    if (!targetSessionId) {
+      return;
+    }
+    try {
+      await this.httpClient.delete(`/v1/sessions/${targetSessionId}`);
+      if (targetSessionId === this._sessionId) {
+        this._sessionId = null;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`Failed to close session ${targetSessionId}:`, errorMessage);
+    }
+  }
+  /**
+   * Get usage statistics for a session
+   */
+  async getUsage(sessionId) {
+    const targetSessionId = sessionId || this._sessionId;
+    if (!targetSessionId) {
+      throw new SessionError("No active session to get usage for");
+    }
+    try {
+      const response = await this.httpClient.get(
+        `/v1/sessions/usage/${targetSessionId}`
+      );
+      return {
+        sessionsUsed: response.sessions_used || 0,
+        executionTime: response.execution_time || 0,
+        quotaRemaining: response.quota_remaining || 0,
+        quotaLimit: response.quota_limit || 0
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new SessionError(
+        `Failed to get usage stats: ${errorMessage}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Get the current session ID
+   */
+  get sessionId() {
+    return this._sessionId;
+  }
+  /**
+   * Clean up resources
+   */
+  async dispose() {
+    if (this._sessionId) {
+      await this.closeSession();
+    }
+    await this.browser.dispose();
+  }
+};
+export {
+  AuthenticationError,
+  BrowserError,
+  BrowserInteractionError,
+  BrowserManager,
+  BrowserNavigationError,
+  BrowserSession,
+  BrowserSessionError,
+  BrowserTimeoutError,
+  ElementNotFoundError,
+  ExecutionError,
+  InstaVM,
+  InstaVMError,
+  NetworkError,
+  QuotaExceededError,
+  RateLimitError,
+  SessionError
+};
+//# sourceMappingURL=index.mjs.map