@scalar/agent-chat 0.2.3 → 0.2.6

package/dist/entities/tools/get-openapi-spec-summary.js

@@ -0,0 +1,4 @@
+const _ = "get-openapi-specs-summary";
+export {
+  _ as GET_OPENAPI_SPECS_SUMMARY_TOOL_NAME
+};

package/dist/helpers.d.ts

@@ -1,4 +1,3 @@
-import type { ToolUIPart, UIDataTypes, UIMessagePart } from 'ai';
 import type { MergedSecuritySchemes } from '@scalar/api-client/v2/blocks/scalar-auth-selector-block';
 import type { OpenAPIV3_1 } from '@scalar/openapi-types';
 import type { AuthenticationConfiguration } from '@scalar/types/api-reference';
@@ -7,7 +6,8 @@ import type { WorkspaceDocument } from '@scalar/workspace-store/schemas';
 import type { XScalarSelectedSecurity } from '@scalar/workspace-store/schemas/extensions/security/x-scalar-selected-security';
 import type { OpenApiDocument, OperationObject, ParameterObject, PathItemObject, SecurityRequirementObject, SecuritySchemeObject, ServerObject } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
 import { type SecuritySchemes } from '@scalar/workspace-store/schemas/v3.1/strict/openapi-document';
-import type { Tools } from './state/state';
+import type { ToolUIPart, UIDataTypes, UIMessagePart } from 'ai';
+import type { Tools } from './state/state.js';
 /** Combine pathItem and operation parameters into a single, dereferenced parameter array */
 export declare const combineParams: (pathParams?: PathItemObject["parameters"], operationParams?: OperationObject["parameters"]) => ParameterObject[];
 /**
@@ -80,7 +80,7 @@ export declare const authStorage: () => {
             'x-scalar-secret-token': string;
         } & {
             type: "apiKey";
-            in: "header" | "query" | "cookie";
+            in: "cookie" | "query" | "header";
             name: string;
         }) | ({
             description?: string | undefined;
@@ -125,7 +125,7 @@ export declare const authStorage: () => {
                 } & {
                     'x-scalar-secret-client-secret': string;
                 } & {
-                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 }) | undefined;
                 implicit?: ({
                     refreshUrl: string;
@@ -175,7 +175,7 @@ export declare const authStorage: () => {
                 } & {
                     'x-scalar-secret-client-secret': string;
                 } & {
-                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 }) | undefined;
                 authorizationCode?: ({
                     refreshUrl: string;
@@ -206,7 +206,7 @@ export declare const authStorage: () => {
                 } & {
                     'x-usePkce': "SHA-256" | "plain" | "no";
                 } & {
-                    'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                    'x-scalar-credentials-location'?: "header" | "body" | undefined;
                 }) | undefined;
             };
         } & {
@@ -217,11 +217,11 @@ export declare const authStorage: () => {
             type: "openIdConnect";
             openIdConnectUrl: string;
         }) | ({
-            summary?: string | undefined;
             description?: string | undefined;
+            summary?: string | undefined;
             $ref: string;
         } & {
-            $status?: "error" | "loading" | undefined;
+            $status?: "loading" | "error" | undefined;
             $global?: boolean | undefined;
         } & {
             '$ref-value': ({
@@ -230,7 +230,7 @@ export declare const authStorage: () => {
                 'x-scalar-secret-token': string;
             } & {
                 type: "apiKey";
-                in: "header" | "query" | "cookie";
+                in: "cookie" | "query" | "header";
                 name: string;
             }) | ({
                 description?: string | undefined;
@@ -275,7 +275,7 @@ export declare const authStorage: () => {
                     } & {
                         'x-scalar-secret-client-secret': string;
                     } & {
-                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                        'x-scalar-credentials-location'?: "header" | "body" | undefined;
                     }) | undefined;
                     implicit?: ({
                         refreshUrl: string;
@@ -325,7 +325,7 @@ export declare const authStorage: () => {
                     } & {
                         'x-scalar-secret-client-secret': string;
                     } & {
-                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                        'x-scalar-credentials-location'?: "header" | "body" | undefined;
                     }) | undefined;
                     authorizationCode?: ({
                         refreshUrl: string;
@@ -356,7 +356,7 @@ export declare const authStorage: () => {
                     } & {
                         'x-usePkce': "SHA-256" | "plain" | "no";
                     } & {
-                        'x-scalar-credentials-location'?: "body" | "header" | undefined;
+                        'x-scalar-credentials-location'?: "header" | "body" | undefined;
                     }) | undefined;
                 };
             } & {
@@ -415,4 +415,12 @@ export declare const restoreAuthSecretsFromStorage: ({ documentName, workspaceSt
     workspaceStore: WorkspaceStore;
 }) => void;
 export declare function safeParseJson(value: string): any;
+export type AgentChatError<T extends string = string, D = unknown> = {
+    code: T;
+    detail: D;
+};
+export declare const AgentErrorCodes: {
+    readonly LIMIT_REACHED: "LIMIT_REACHED";
+};
+export declare function createError<const T extends string, D>(code: T, detail: D): AgentChatError<T, D>;
 //# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

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

package/dist/helpers.js

@@ -0,0 +1,122 @@
+import { getSelectedServer as E } from "@scalar/api-client/v2/features/operation";
+import { getServers as O } from "@scalar/api-client/v2/helpers";
+import { isObject as l } from "@scalar/helpers/object/is-object";
+import { REFERENCE_LS_KEYS as d, safeLocalStorage as I } from "@scalar/helpers/object/local-storage";
+import { getResolvedRef as u } from "@scalar/workspace-store/helpers/get-resolved-ref";
+import { coerceValue as f } from "@scalar/workspace-store/schemas/typebox-coerce";
+import { XScalarSelectedSecuritySchema as b, SecuritySchemesSchema as v } from "@scalar/workspace-store/schemas/v3.1/strict/openapi-document";
+function D(e) {
+  return Object.values(e.paths ?? {}).flatMap((s) => Object.values(s ?? {}));
+}
+function j(e) {
+  const c = (e["x-scalar-selected-security"]?.selectedSchemes ?? []).flatMap((r) => Object.keys(r)), t = e.components?.securitySchemes;
+  return t ? c.reduce((r, n) => {
+    const o = t[n];
+    return o && r.push(u(o)), r;
+  }, []) : [];
+}
+function T(e) {
+  return Object.fromEntries(
+    Object.entries(e.workspace.documents).map(([s, c]) => {
+      const t = O(c.servers, {
+        documentUrl: c?.["x-scalar-original-source-url"]
+      });
+      return [
+        s,
+        {
+          activeServer: E(c, t),
+          securitySchemes: j(c)
+        }
+      ];
+    })
+  );
+}
+const m = I(), y = () => {
+  const e = d.AUTH_SCHEMES, s = d.SELECTED_AUTH_SCHEMES, c = (t, r) => `${r}-${((o) => o === "schemas" ? e : s)(t)}`;
+  return {
+    /**
+     * Retrieves and coerces the authentication schemes stored in local storage.
+     */
+    getSchemas: (t) => {
+      const r = JSON.parse(m.getItem(c("schemas", t)) ?? "{}");
+      return f(v, r);
+    },
+    /**
+     * Stores the authentication schemes in local storage.
+     * @param value The SecuritySchemes object to stringify and store.
+     */
+    setSchemas: (t, r) => {
+      m.setItem(c("schemas", t), JSON.stringify(r));
+    },
+    /**
+     * Retrieves and coerces the selected authentication schemes stored in local storage.
+     */
+    getSelectedSchemes: (t) => {
+      const r = JSON.parse(m.getItem(c("selectedSchemes", t)) ?? "{}");
+      return f(b, r);
+    },
+    /**
+     * Stores the user's selected authentication schemes in local storage.
+     * @param value The XScalarSelectedSecurity object to stringify and store.
+     */
+    setSelectedSchemes: (t, r) => {
+      m.setItem(c("selectedSchemes", t), JSON.stringify(r));
+    }
+  };
+}, p = (e, s) => {
+  if (!(!l(e) || !l(s)))
+    for (const [c, t] of Object.entries(s)) {
+      if (typeof t != "object") {
+        e[c] = t;
+        continue;
+      }
+      p(u(e[c]), t);
+    }
+}, x = (e, s) => Object.keys(e).every((c) => s.has(c)), A = (e, s) => e >= s ? s - 1 : e, L = ({
+  documentName: e,
+  workspaceStore: s
+}) => {
+  const c = y().getSchemas(e), t = s.workspace.documents[e];
+  if (!t)
+    return;
+  const n = y().getSelectedSchemes(e), o = new Set(Object.keys(t.components?.securitySchemes ?? {})), a = n["x-scalar-selected-security"]?.selectedSchemes?.filter((S) => x(S, o));
+  if (!t["x-scalar-selected-security"] && a && a.length > 0) {
+    const S = n["x-scalar-selected-security"]?.selectedIndex, i = A(S ?? 0, a.length);
+    t["x-scalar-selected-security"] = {
+      selectedIndex: i,
+      selectedSchemes: a
+    };
+  }
+  const g = t.components?.securitySchemes ?? {};
+  for (const [S, i] of Object.entries(c)) {
+    const h = u(g[S]);
+    l(h) && p(h, i);
+  }
+};
+function N(e) {
+  try {
+    return JSON.parse(e);
+  } catch {
+    return;
+  }
+}
+const w = {
+  LIMIT_REACHED: "LIMIT_REACHED"
+};
+function F(e, s) {
+  return {
+    code: e,
+    detail: s
+  };
+}
+export {
+  w as AgentErrorCodes,
+  y as authStorage,
+  T as createDocumentSettings,
+  F as createError,
+  D as getOperations,
+  j as getSecurityFromDocument,
+  p as mergeSecrets,
+  L as restoreAuthSecretsFromStorage,
+  N as safeParseJson
+};

package/dist/hooks/{useChatApprovals.d.ts → use-chat-approvals.d.ts}

@@ -21,4 +21,4 @@ export declare function useChatApprovals(): {
     })[]>;
     respondToToolCalls: (approved: boolean) => Promise<void>;
 };
-//# sourceMappingURL=useChatApprovals.d.ts.map
+//# sourceMappingURL=use-chat-approvals.d.ts.map

package/dist/hooks/use-chat-approvals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-approvals.d.ts","sourceRoot":"","sources":["../../src/hooks/use-chat-approvals.ts"],"names":[],"mappings":"AAWA,wBAAgB,gBAAgB;;;;;;;;;;;;;;;oBAuB648C,CAAC;kBAAuB,CAAC;;;eA7B/48C,oBAAoB;;mCAgB7B,OAAO;EAYpD"}

package/dist/hooks/use-chat-approvals.js

@@ -0,0 +1,21 @@
+import { computed as l } from "vue";
+import { useState as n } from "../state/state.js";
+function e(t) {
+  return t.type.startsWith("tool") && t.state === "approval-requested";
+}
+function c() {
+  const t = n(), a = l(() => t.chat.messages.filter((o) => o.parts.some(e)).flatMap((o) => o.parts).filter(e));
+  async function s(o) {
+    const r = a.value.map(
+      (p) => t.chat.addToolApprovalResponse({
+        id: p.approval.id,
+        approved: o
+      })
+    );
+    await Promise.all(r);
+  }
+  return { approvalRequestedParts: a, respondToToolCalls: s };
+}
+export {
+  c as useChatApprovals
+};

package/dist/hooks/use-chat-error.d.ts

@@ -0,0 +1,14 @@
+import { z } from 'zod/mini';
+declare const chatErrorSchema: z.ZodMiniObject<{
+    message: z.ZodMiniString<string>;
+    code: z.ZodMiniString<string>;
+    status: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+}, z.core.$strip>;
+export type ChatError = z.infer<typeof chatErrorSchema>;
+export declare function useChatError(): import("vue").ComputedRef<{
+    message: string;
+    code: string;
+    status?: number | undefined;
+} | undefined>;
+export {};
+//# sourceMappingURL=use-chat-error.d.ts.map

package/dist/hooks/use-chat-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-error.d.ts","sourceRoot":"","sources":["../../src/hooks/use-chat-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,UAAU,CAAA;AAK5B,QAAA,MAAM,eAAe;;;;iBAInB,CAAA;AACF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAEvD,wBAAgB,YAAY;;;;eAiB3B"}

package/dist/hooks/use-chat-error.js

@@ -0,0 +1,23 @@
+import { computed as t } from "vue";
+import { z as r } from "zod/mini";
+import { safeParseJson as a } from "../helpers.js";
+import { useState as n } from "../state/state.js";
+const m = r.object({
+  message: r.string(),
+  code: r.string(),
+  status: r.optional(r.number())
+});
+function p() {
+  const { chat: e } = n();
+  return t(() => {
+    if (!e.error) return;
+    const o = a(e.error.message), s = m.safeParse(o);
+    return !o || !s.success ? {
+      message: e.error.message,
+      code: "UNKNOWN_ERROR"
+    } : s.data;
+  });
+}
+export {
+  p as useChatError
+};

package/dist/hooks/use-chat-pending-client-tool-parts.d.ts

@@ -0,0 +1,19 @@
+export declare function useChatPendingClientToolParts(): {
+    pendingClientToolParts: import("vue").ComputedRef<({
+        type: `tool-${string}`;
+    } & {
+        toolCallId: string;
+        title?: string;
+        providerExecuted?: boolean;
+    } & {
+        state: "input-available";
+        input: unknown;
+        output?: never;
+        errorText?: never;
+        callProviderMetadata?: import("ai").ProviderMetadata;
+        approval?: never;
+    } & {
+        state: "input-available";
+    })[]>;
+};
+//# sourceMappingURL=use-chat-pending-client-tool-parts.d.ts.map

package/dist/hooks/use-chat-pending-client-tool-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-pending-client-tool-parts.d.ts","sourceRoot":"","sources":["../../src/hooks/use-chat-pending-client-tool-parts.ts"],"names":[],"mappings":"AAWA,wBAAgB,6BAA6B;;;;;;;;;;;;;;;eANM,iBAAiB;;EAiBnE"}

package/dist/hooks/use-chat-pending-client-tool-parts.js

@@ -0,0 +1,12 @@
+import { computed as o } from "vue";
+import { useState as r } from "../state/state.js";
+function n(t) {
+  return t.type.startsWith("tool") && t.state === "input-available";
+}
+function l() {
+  const t = r();
+  return { pendingClientToolParts: o(() => t.chat.messages.filter((e) => e.parts.some(n)).flatMap((e) => e.parts).filter(n)) };
+}
+export {
+  l as useChatPendingClientToolParts
+};

package/dist/hooks/{useChatScroll.d.ts → use-chat-scroll.d.ts}

@@ -1,2 +1,2 @@
 export declare function useChatScroll(): void;
-//# sourceMappingURL=useChatScroll.d.ts.map
+//# sourceMappingURL=use-chat-scroll.d.ts.map

package/dist/hooks/use-chat-scroll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-chat-scroll.d.ts","sourceRoot":"","sources":["../../src/hooks/use-chat-scroll.ts"],"names":[],"mappings":"AAKA,wBAAgB,aAAa,SAgB5B"}

package/dist/hooks/use-chat-scroll.js

@@ -0,0 +1,16 @@
+import { watch as r, nextTick as s } from "vue";
+import { useState as n } from "../state/state.js";
+function u() {
+  const e = n();
+  function o(a) {
+    const t = a?.parts.at(-1);
+    if (t && t.type === "text")
+      return t.text;
+  }
+  r([() => e.chat.status, () => o(e.chat.lastMessage)], async () => {
+    await s(), window.scrollTo(0, document.body.scrollHeight);
+  });
+}
+export {
+  u as useChatScroll
+};

package/dist/hooks/{useSearch.d.ts → use-search.d.ts}

@@ -1,26 +1,26 @@
-export declare function useSearch(baseUrl: string): {
+export declare function useSearch(): {
     query: import("vue").WritableComputedRef<string, string>;
     results: import("vue").Ref<{
-        namespace: string;
-        slug: string;
         id: string;
         title: string;
-        logoUrl: string | null;
-        currentVersion: string;
-    }[], {
         namespace: string;
+        currentVersion: string;
+        logoUrl: string | null;
         slug: string;
+    }[], {
         id: string;
         title: string;
-        logoUrl: string | null;
-        currentVersion: string;
-    }[] | {
         namespace: string;
+        currentVersion: string;
+        logoUrl: string | null;
         slug: string;
+    }[] | {
         id: string;
         title: string;
-        logoUrl: string | null;
+        namespace: string;
         currentVersion: string;
+        logoUrl: string | null;
+        slug: string;
     }[]>;
 };
-//# sourceMappingURL=useSearch.d.ts.map
+//# sourceMappingURL=use-search.d.ts.map

package/dist/hooks/use-search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-search.d.ts","sourceRoot":"","sources":["../../src/hooks/use-search.ts"],"names":[],"mappings":"AAOA,wBAAgB,SAAS;;;;;;;;;;;;;;;;;;;;;;;;EAoCxB"}

package/dist/hooks/use-search.js

@@ -0,0 +1,25 @@
+import { useDebounceFn as m } from "@vueuse/core";
+import { ref as c, computed as f } from "vue";
+import { api as i } from "../api.js";
+import { useState as p } from "../state/state.js";
+function d() {
+  const { baseUrl: u, getAccessToken: n } = p(), s = c(""), r = m(async (e) => {
+    const o = await i({
+      baseUrl: u,
+      getAccessToken: n
+    }).search(e);
+    o.success && (t.value = o.data.results);
+  }, 200), a = f({
+    get: () => s.value,
+    set: (e) => {
+      r(e), s.value = e;
+    }
+  }), t = c([]);
+  return r(""), {
+    query: a,
+    results: t
+  };
+}
+export {
+  d as useSearch
+};

package/dist/hooks/use-term-and-conditions.d.ts

@@ -0,0 +1,6 @@
+export declare const TERMS_AND_CONDITIONS_LS_KEY = "scalar/agent-terms-accepted";
+export declare function useTermsAndConditions(): {
+    accepted: import("vue").Ref<boolean, boolean>;
+    accept: () => void;
+};
+//# sourceMappingURL=use-term-and-conditions.d.ts.map

package/dist/hooks/use-term-and-conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-term-and-conditions.d.ts","sourceRoot":"","sources":["../../src/hooks/use-term-and-conditions.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,2BAA2B,gCAAgC,CAAA;AAExE,wBAAgB,qBAAqB;;;EAapC"}

package/dist/hooks/use-term-and-conditions.js

@@ -0,0 +1,16 @@
+import { ref as r, onMounted as a } from "vue";
+const t = "scalar/agent-terms-accepted";
+function n() {
+  const e = r(!1);
+  a(() => {
+    e.value = localStorage.getItem(t) === "true";
+  });
+  function o() {
+    e.value = !0, localStorage.setItem(t, "true");
+  }
+  return { accepted: e, accept: o };
+}
+export {
+  t as TERMS_AND_CONDITIONS_LS_KEY,
+  n as useTermsAndConditions
+};

package/dist/hooks/use-upload-tmp-document.d.ts

@@ -0,0 +1,19 @@
+import type { WorkspaceDocument } from '@scalar/workspace-store/schemas';
+export type UploadTmpDocumentState = {
+    type: 'error';
+    error: unknown;
+} | {
+    type: 'uploading';
+} | {
+    type: 'processing';
+} | {
+    type: 'done';
+};
+export declare function useUploadTmpDocument(): {
+    uploadTempDocument: (document: WorkspaceDocument) => Promise<{
+        namespace: string;
+        slug: string;
+    } | undefined>;
+    uploadState: import("vue").Ref<UploadTmpDocumentState | undefined, UploadTmpDocumentState | undefined>;
+};
+//# sourceMappingURL=use-upload-tmp-document.d.ts.map

package/dist/hooks/use-upload-tmp-document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-upload-tmp-document.d.ts","sourceRoot":"","sources":["../../src/hooks/use-upload-tmp-document.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAA;AAMxE,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GACjC;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,GACrB;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEpB,wBAAgB,oBAAoB;mCAeU,iBAAiB;;;;;EAgE9D"}

package/dist/hooks/use-upload-tmp-document.js

@@ -0,0 +1,64 @@
+import { ref as p } from "vue";
+import { z as n } from "zod/mini";
+import { useState as d } from "../state/state.js";
+function g() {
+  const u = d(), e = p();
+  function s(r) {
+    const t = `${u.baseUrl}${r}`;
+    if (t.startsWith("/")) return t;
+    const o = new URLSearchParams({ scalar_url: t.toString() });
+    return new URL(`https://proxy.scalar.com/?${o}`);
+  }
+  async function c(r) {
+    try {
+      e.value = { type: "uploading" };
+      const t = await fetch(s("/core/share/upload/apis"), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ document: JSON.stringify(r) })
+      });
+      if (!t.ok) {
+        e.value = {
+          type: "error",
+          error: "Failed to upload document."
+        };
+        return;
+      }
+      const o = await t.json(), { success: i, data: a } = n.object({ namespace: n.string(), slug: n.string() }).safeParse(o);
+      if (!i) {
+        e.value = {
+          type: "error",
+          error: "Failed to process document."
+        };
+        return;
+      }
+      if (e.value = {
+        type: "processing"
+      }, !(await fetch(
+        s(`/vector/registry/embeddings/${a.namespace}/${a.slug}`),
+        {
+          method: "GET"
+        }
+      )).ok) {
+        e.value = {
+          type: "error",
+          error: "Failed to embed document."
+        };
+        return;
+      }
+      return e.value = { type: "done" }, setTimeout(() => {
+        e.value = void 0;
+      }, 2e3), a;
+    } catch {
+      e.value = { type: "error", error: "Failed to upload document." };
+      return;
+    }
+  }
+  return {
+    uploadTempDocument: c,
+    uploadState: e
+  };
+}
+export {
+  g as useUploadTmpDocument
+};

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-export { default as Chat } from './App.vue';
+import './style.css';
+export { default as Chat } from './App.vue.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,CAAA;AAEpB,OAAO,EAAE,OAAO,IAAI,IAAI,EAAE,MAAM,WAAW,CAAA"}

package/dist/index.js

@@ -1,4 +1,5 @@
-import { _ as r } from "./index-BOvT43H8.js";
+/* empty css          */
+import { default as r } from "./App.vue.js";
 export {
   r as Chat
 };