@worktango/ai-assistant 0.0.132 → 0.0.133

package/build/express.d.ts

@@ -0,0 +1,2 @@
+export { setupAiAssistantRoutes } from "./src/backend/express";
+export * from "./backendTypes";

package/build/express.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupAiAssistantRoutes = void 0;
+var express_1 = require("./src/backend/express");
+Object.defineProperty(exports, "setupAiAssistantRoutes", { enumerable: true, get: function () { return express_1.setupAiAssistantRoutes; } });
+__exportStar(require("./backendTypes"), exports);
+//# sourceMappingURL=express.js.map

package/build/react.d.ts

@@ -0,0 +1,4 @@
+export * from "./src/frontend/reactComponent";
+export * as config from "./src/frontend/config";
+export * as tools from "./src/frontend/tools/llm-tools";
+export * from "./sharedTypes";

package/build/react.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tools = exports.config = void 0;
+__exportStar(require("./src/frontend/reactComponent"), exports);
+exports.config = __importStar(require("./src/frontend/config"));
+exports.tools = __importStar(require("./src/frontend/tools/llm-tools"));
+__exportStar(require("./sharedTypes"), exports);
+//# sourceMappingURL=react.js.map

package/build/src/backend/express.d.ts

@@ -0,0 +1,63 @@
+import type { Express, RequestHandler } from "express";
+import type { RestEndpointCallbacks, GraphQLOperationCallbacks } from "./types";
+/**
+ * Note: the inline TypeScript documentation for the below is in `../../express.d.ts`.
+ * This is optimized for external use, so we don't want to duplicate the docs here.
+ */
+export declare function setupAiAssistantRoutes(args: {
+    app: Express;
+    getBearerToken: (headers: Record<string, undefined | string | string[]>) => Promise<string>;
+    targetHost: string;
+    targetPort?: number;
+    targetProtocol?: string;
+    route?: string;
+    logger?: Pick<typeof console, "log" | "error" | "debug">;
+    preflightMiddlewares?: RequestHandler[];
+    getTargetPath: (path: string) => string;
+    followRedirects?: boolean;
+    /**
+     * Optional callbacks to invoke after successful REST endpoint responses (status 200 only).
+     * Provides access to both request and response data with full type safety.
+     *
+     * @example
+     * ```typescript
+     * onRestEndpointSuccess: {
+     *   '/api/api-ai-assistant/v1/chat': async ({ request, response }) => {
+     *     console.log('Chat completed successfully');
+     *     // response is typed as ChatResponse
+     *     console.log('Model response:', response.role, response.parts);
+     *   },
+     *   '/api/api-ai-assistant/v1/tts': async ({ request, response }) => {
+     *     // response is typed as TTSResponse
+     *     console.log('Speech synthesis:', response.synthesis);
+     *   },
+     * }
+     * ```
+     */
+    onRestEndpointSuccess?: RestEndpointCallbacks;
+    /**
+     * Optional callbacks to invoke after successful GraphQL operation responses (status 200 only).
+     * Keys must match the GraphQL operation names (PascalCase), not field names.
+     * Provides access to both request and response data with full type safety.
+     *
+     * @example
+     * ```typescript
+     * onGraphQLOperationSuccess: {
+     *   AppendMessageToConversation: async ({ request, response }) => {
+     *     // Extract the conversation ID from the typed response
+     *     const conversationId = response.data?.appendMessage?.conversation?.id;
+     *     if (conversationId) {
+     *       // Store in localStorage, update UI state, trigger analytics, etc.
+     *       localStorage.setItem('lastConversationId', conversationId);
+     *       console.log('New conversation created:', conversationId);
+     *     }
+     *   },
+     *   GetAllConversations: async ({ request, response }) => {
+     *     const conversations = response.data?.getConversations;
+     *     console.log(`Loaded ${conversations?.length ?? 0} conversations`);
+     *   },
+     * }
+     * ```
+     */
+    onGraphQLOperationSuccess?: GraphQLOperationCallbacks;
+}): void;

package/build/src/backend/express.js

@@ -0,0 +1,366 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupAiAssistantRoutes = setupAiAssistantRoutes;
+const http_proxy_middleware_1 = require("http-proxy-middleware");
+const helpers_1 = require("@kazoohr/helpers");
+/**
+ * Note: the inline TypeScript documentation for the below is in `../../express.d.ts`.
+ * This is optimized for external use, so we don't want to duplicate the docs here.
+ */
+function setupAiAssistantRoutes(args) {
+    const logger = (0, helpers_1.coalesce)(args.logger, console);
+    const routePath = args.route ?? "/ai-assistant";
+    const port = args.targetPort ?? 80;
+    const protocol = args.targetProtocol ?? "http";
+    // This initial middleware mutates the request headers for the proxy request
+    // so that we can add the bearer token to the request. We need this separate
+    // because the proxy middleware callbacks cannot be async.
+    const bearerTokenMiddleware = (req, res, next) => {
+        args
+            .getBearerToken(req.headers)
+            .then((bearerToken) => {
+            getRequestWithNewAuthHeader(req).newAuthHeader = `Bearer ${bearerToken}`;
+            next();
+        })
+            .catch((error) => {
+            logger.error("Error getting bearer token:", error);
+            next(error);
+        });
+    };
+    const proxyOptions = {
+        target: `${protocol}://${args.targetHost}:${port}`,
+        changeOrigin: true,
+        followRedirects: args.followRedirects ?? true,
+        secure: protocol === "https",
+        pathRewrite: (path, req) => {
+            // Since we use express, we know that req.originalUrl is available
+            const expressRequest = req; // eslint-disable-line @typescript-eslint/consistent-type-assertions
+            return args.getTargetPath(expressRequest.originalUrl || path);
+        },
+        on: {
+            proxyReq: (proxyReq, req) => {
+                const newAuthHeader = getRequestWithNewAuthHeader(req).newAuthHeader;
+                if (newAuthHeader) {
+                    proxyReq.setHeader("Authorization", newAuthHeader);
+                }
+                (0, http_proxy_middleware_1.fixRequestBody)(proxyReq, req);
+            },
+            proxyRes: (proxyRes, req, res) => {
+                if (proxyRes.statusCode !== 200) {
+                    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+                    const originalUrl = req
+                        .originalUrl;
+                    logger.error(`[setupAiAssistantRoutes] Proxy error ${proxyRes.statusCode}: ${originalUrl}`);
+                }
+                // istanbul ignore else - noop, normal request
+                if (req.headers.accept === "text/event-stream") {
+                    res.writeHead(res.statusCode, {
+                        "Content-Type": "text/event-stream",
+                        "Cache-Control": "no-transform",
+                        Connection: "keep-alive",
+                    });
+                }
+                // Handle callbacks for successful responses
+                if (proxyRes.statusCode === 200 &&
+                    (args.onRestEndpointSuccess || args.onGraphQLOperationSuccess)) {
+                    handleSuccessCallback({
+                        proxyRes,
+                        req,
+                        logger,
+                        onRestEndpointSuccess: args.onRestEndpointSuccess,
+                        onGraphQLOperationSuccess: args.onGraphQLOperationSuccess,
+                    });
+                }
+            },
+            error: (err, req, res) => {
+                logger.error("[setupAiAssistantRoutes] Proxy error:", err);
+                if ("headersSent" in res && !res.headersSent) {
+                    res.statusCode = 502;
+                    res.write("Bad Gateway");
+                    res.end();
+                }
+            },
+        },
+    };
+    logger.debug("[setupAiAssistantRoutes] Setting up AI Assistant proxy:", proxyOptions);
+    const proxy = (0, http_proxy_middleware_1.createProxyMiddleware)(proxyOptions);
+    args.app.use(routePath, ...(0, helpers_1.coalesce)(args.preflightMiddlewares, []), bearerTokenMiddleware, proxy);
+}
+/**
+ * This function gets around needing to add new global types that are only
+ * needed for this one function.
+ */
+function getRequestWithNewAuthHeader(req) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return req;
+}
+/**
+ * Handles success callbacks by buffering the response and invoking the
+ * appropriate callback based on the request type
+ */
+function handleSuccessCallback(args) {
+    const { proxyRes, req, logger, onRestEndpointSuccess, onGraphQLOperationSuccess, } = args;
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const expressRequest = req;
+    const targetPath = expressRequest.path || expressRequest.url || "";
+    const requestBody = expressRequest.body;
+    // Buffer the response data
+    const chunks = [];
+    proxyRes.on("data", (chunk) => {
+        chunks.push(chunk);
+    });
+    proxyRes.on("end", () => {
+        processBufferedResponse({
+            chunks,
+            requestBody,
+            targetPath,
+            expressRequest,
+            logger,
+            onRestEndpointSuccess,
+            onGraphQLOperationSuccess,
+        });
+    });
+}
+/**
+ * Processes the buffered response and routes to appropriate callbacks
+ */
+function processBufferedResponse(args) {
+    const { chunks, requestBody, targetPath, expressRequest, logger, onRestEndpointSuccess, onGraphQLOperationSuccess, } = args;
+    try {
+        const responseBody = Buffer.concat(chunks).toString("utf8");
+        // Skip callback if response is empty
+        if (!responseBody) {
+            return;
+        }
+        const parsedResponse = tryParseJSON(responseBody, logger);
+        if (!parsedResponse) {
+            return;
+        }
+        routeCallback({
+            requestBody,
+            parsedResponse,
+            targetPath,
+            expressRequest,
+            logger,
+            onRestEndpointSuccess,
+            onGraphQLOperationSuccess,
+        });
+    }
+    catch (error) {
+        // Don't let callback errors break the proxy
+        logger.error("[setupAiAssistantRoutes] Error in success callback:", error);
+    }
+}
+/**
+ * Routes the parsed response to the appropriate callback handler
+ */
+function routeCallback(args) {
+    const { requestBody, parsedResponse, targetPath, expressRequest, logger, onRestEndpointSuccess, onGraphQLOperationSuccess, } = args;
+    const isGraphQLRequest = isGraphQLRequestBody(requestBody);
+    if (isGraphQLRequest && onGraphQLOperationSuccess) {
+        handleGraphQLCallback({
+            requestBody,
+            parsedResponse,
+            expressRequest,
+            onGraphQLOperationSuccess,
+            logger,
+        });
+    }
+    else if (!isGraphQLRequest && onRestEndpointSuccess) {
+        handleRestCallback({
+            targetPath,
+            requestBody,
+            parsedResponse,
+            expressRequest,
+            onRestEndpointSuccess,
+            logger,
+        });
+    }
+}
+/**
+ * Attempts to parse JSON response body
+ */
+function tryParseJSON(responseBody, logger) {
+    try {
+        return JSON.parse(responseBody);
+    }
+    catch (error) {
+        // If it's not JSON (e.g., streaming response), skip callback
+        logger.debug("[setupAiAssistantRoutes] Response is not JSON, skipping callback");
+        return undefined;
+    }
+}
+/**
+ * Checks if an object has GraphQL operation fields
+ */
+function hasGraphQLFields(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        ("operationName" in item || "query" in item));
+}
+/**
+ * Checks if request body indicates a GraphQL request
+ */
+function isGraphQLRequestBody(requestBody) {
+    // Handle single GraphQL operation
+    if (!Array.isArray(requestBody)) {
+        return hasGraphQLFields(requestBody);
+    }
+    // Handle batched GraphQL operations
+    if (requestBody.length > 0) {
+        return hasGraphQLFields(requestBody[0]);
+    }
+    return false;
+}
+/**
+ * Handles GraphQL operation callbacks
+ */
+function handleGraphQLCallback(args) {
+    const { requestBody, parsedResponse, expressRequest, onGraphQLOperationSuccess, logger, } = args;
+    // Handle batched GraphQL requests
+    if (Array.isArray(requestBody)) {
+        handleBatchedGraphQLCallbacks({
+            requestBodies: requestBody,
+            parsedResponse,
+            expressRequest,
+            onGraphQLOperationSuccess,
+            logger,
+        });
+        return;
+    }
+    // Handle single GraphQL request
+    const operationName = extractGraphQLOperationName(requestBody, logger);
+    if (!operationName) {
+        return;
+    }
+    const callback = onGraphQLOperationSuccess[operationName];
+    if (callback) {
+        invokeGraphQLCallback({
+            callback,
+            requestBody,
+            parsedResponse,
+            expressRequest,
+            operationName,
+            logger,
+        });
+    }
+}
+/**
+ * Handles batched GraphQL operation callbacks
+ */
+function handleBatchedGraphQLCallbacks(args) {
+    const { requestBodies, parsedResponse, expressRequest, onGraphQLOperationSuccess, logger, } = args;
+    // Response should also be an array for batched requests
+    const responses = Array.isArray(parsedResponse)
+        ? parsedResponse
+        : [parsedResponse];
+    // Process each operation in the batch
+    requestBodies.forEach((requestBody, index) => {
+        const operationName = extractGraphQLOperationName(requestBody, logger);
+        if (!operationName) {
+            return;
+        }
+        const callback = onGraphQLOperationSuccess[operationName];
+        if (!callback) {
+            return;
+        }
+        // Match the request with its corresponding response
+        const response = responses[index] || parsedResponse;
+        invokeGraphQLCallback({
+            callback,
+            requestBody,
+            parsedResponse: response,
+            expressRequest,
+            operationName,
+            logger,
+        });
+    });
+}
+/**
+ * Extracts the GraphQL operation name from request body
+ */
+function extractGraphQLOperationName(requestBody, logger) {
+    if (typeof requestBody !== "object" || requestBody === null) {
+        return undefined;
+    }
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const body = requestBody;
+    // First, check if operationName is explicitly provided
+    if (body.operationName) {
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        return body.operationName;
+    }
+    // Try to extract from query string
+    if (body.query) {
+        const match = body.query.match(/(?:query|mutation)\s+(\w+)/);
+        if (match) {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            return match[1];
+        }
+    }
+    logger.debug("[setupAiAssistantRoutes] Could not determine GraphQL operation name");
+    return undefined;
+}
+/**
+ * Invokes a GraphQL callback with the provided context
+ * Type assertion is necessary because callbacks have specific request/response types
+ * but we're working with unknown at runtime
+ */
+function invokeGraphQLCallback(args) {
+    const { callback, requestBody, parsedResponse, expressRequest, operationName, logger, } = args;
+    const context = {
+        request: {
+            path: expressRequest.path || expressRequest.url || "",
+            method: expressRequest.method || "POST",
+            body: requestBody,
+        },
+        response: parsedResponse,
+    };
+    // Type assertion needed: callback expects specific CallbackContext types,
+    // but we can only provide CallbackContext<unknown, unknown> at runtime
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const typedCallback = callback;
+    Promise.resolve(typedCallback(context)).catch((error) => {
+        logger.error(`[setupAiAssistantRoutes] Error in GraphQL callback for ${operationName}:`, error);
+    });
+}
+/**
+ * Handles REST endpoint callbacks
+ */
+function handleRestCallback(args) {
+    const { targetPath, requestBody, parsedResponse, expressRequest, onRestEndpointSuccess, logger, } = args;
+    const matchingPath = findMatchingRestEndpoint(targetPath, onRestEndpointSuccess);
+    if (!matchingPath) {
+        return;
+    }
+    const callback = onRestEndpointSuccess[matchingPath];
+    if (callback) {
+        // Empty string fallback for path is unreachable since targetPath and expressRequest.path come from same source
+        /* istanbul ignore next */
+        const requestPath = expressRequest.path || expressRequest.url || "";
+        const context = {
+            request: {
+                path: requestPath,
+                method: expressRequest.method || "POST",
+                body: requestBody,
+            },
+            response: parsedResponse,
+        };
+        // Type assertion needed: callback expects specific CallbackContext types,
+        // but we can only provide CallbackContext<unknown, unknown> at runtime
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const typedCallback = callback;
+        Promise.resolve(typedCallback(context)).catch((error) => {
+            logger.error(`[setupAiAssistantRoutes] Error in REST callback for ${matchingPath}:`, error);
+        });
+    }
+}
+/**
+ * Finds a matching REST endpoint path from the callbacks
+ */
+function findMatchingRestEndpoint(targetPath, callbacks) {
+    const match = Object.keys(callbacks).find((path) => targetPath.includes(path));
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    return match;
+}
+//# sourceMappingURL=express.js.map

package/dist/{Absenteeism-C9c7V31w.mjs → Absenteeism-BB0vSGG6.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 function e({
   illustrationColor: t
 }) {

package/dist/{ActivityFeed-Bdsq0KNH.mjs → ActivityFeed-BLYkRDEQ.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 function e({
   illustrationColor: t
 }) {

package/dist/{AddUser-CC_EyHv4.mjs → AddUser-CIDBX5Dc.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 const t = ({ variant: o }) => r[o], r = {
   filled: /* @__PURE__ */ C.jsxs(C.Fragment, { children: [
     /* @__PURE__ */ C.jsx(

package/dist/{Admin-zVeXNqK5.mjs → Admin-B9Si37hd.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 function l({ illustrationColor: t }) {
   return /* @__PURE__ */ C.jsxs(C.Fragment, { children: [
     /* @__PURE__ */ C.jsx("title", { children: "Admin illustration" }),

package/dist/{Admin-CY7OeHDB.mjs → Admin-DzzyoyGR.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 const e = ({ variant: t }) => s[t], s = {
   regular: /* @__PURE__ */ C.jsxs(C.Fragment, { children: [
     /* @__PURE__ */ C.jsx(

package/dist/{AiGeneral-DVz3Yxg0.mjs → AiGeneral-KAFQ8rs1.mjs}

@@ -1,4 +1,4 @@
-import { j as L, c as i } from "./reactComponent-pXnU2FiB.mjs";
+import { j as L, c as i } from "./reactComponent-D3nRHRjE.mjs";
 import "react";
 const e = {
   regular: ({ color: C }) => /* @__PURE__ */ L.jsxs("g", { children: [

package/dist/{AiScoring-BCv5Zs0x.mjs → AiScoring-jsIBvcYZ.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 const L = {
   regular: /* @__PURE__ */ C.jsxs("g", { children: [
     /* @__PURE__ */ C.jsxs("g", { clipPath: "url(#clip0_30280_2619)", children: [

package/dist/{AiText-kxd3kO54.mjs → AiText-BDfgezFq.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 const l = {
   regular: /* @__PURE__ */ C.jsxs("g", { children: [
     /* @__PURE__ */ C.jsxs("g", { clipPath: "url(#clip0_30280_2609)", children: [

package/dist/{Anniversary-Ca7-S686.mjs → Anniversary-DijPzGvt.mjs}

@@ -1,4 +1,4 @@
-import { j as s } from "./reactComponent-pXnU2FiB.mjs";
+import { j as s } from "./reactComponent-D3nRHRjE.mjs";
 const e = ({ variant: t }) => c[t] || c.regular, c = {
   thin: void 0,
   regular: /* @__PURE__ */ s.jsxs(s.Fragment, { children: [

package/dist/{Appreciation-DYcuvI1L.mjs → Appreciation-Civ8AH_K.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 function i({
   illustrationColor: L
 }) {

package/dist/{ArrowDown-DxINAnXp.mjs → ArrowDown-CNX2VcYR.mjs}

@@ -1,4 +1,4 @@
-import { j as r } from "./reactComponent-pXnU2FiB.mjs";
+import { j as r } from "./reactComponent-D3nRHRjE.mjs";
 const t = ({ variant: o }) => n[o] || n.regular, n = {
   thin: /* @__PURE__ */ r.jsxs(r.Fragment, { children: [
     /* @__PURE__ */ r.jsx("path", { d: "M12 2L12 21", strokeLinecap: "round", strokeLinejoin: "round" }),

package/dist/{ArrowLeft-BxKT6sqU.mjs → ArrowLeft-CvB8kbCi.mjs}

@@ -1,4 +1,4 @@
-import { j as s } from "./reactComponent-pXnU2FiB.mjs";
+import { j as s } from "./reactComponent-D3nRHRjE.mjs";
 const e = ({ variant: r }) => t[r] || t.regular, t = {
   thin: void 0,
   regular: /* @__PURE__ */ s.jsxs(s.Fragment, { children: [

package/dist/{ArrowRight-DrgitPvX.mjs → ArrowRight-C5205uKr.mjs}

@@ -1,4 +1,4 @@
-import { j as r } from "./reactComponent-pXnU2FiB.mjs";
+import { j as r } from "./reactComponent-D3nRHRjE.mjs";
 const e = ({ variant: t }) => s[t] || s.regular, s = {
   thin: void 0,
   regular: /* @__PURE__ */ r.jsxs(r.Fragment, { children: [

package/dist/{ArrowUp-CP7pYqqV.mjs → ArrowUp-D-Enms4g.mjs}

@@ -1,4 +1,4 @@
-import { j as r } from "./reactComponent-pXnU2FiB.mjs";
+import { j as r } from "./reactComponent-D3nRHRjE.mjs";
 const t = ({ variant: o }) => n[o] || n.regular, n = {
   thin: /* @__PURE__ */ r.jsxs(r.Fragment, { children: [
     /* @__PURE__ */ r.jsx("path", { d: "M12 22L12 3", strokeLinecap: "round", strokeLinejoin: "round" }),

package/dist/{Attachment-BeUjdgtQ.mjs → Attachment-2gW9KFDu.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 const i = ({ variant: t, color: r }) => {
   const e = {
     thin: void 0,

package/dist/{BeQuickDontHurry-BFXf4K19.mjs → BeQuickDontHurry-CX1xPHM5.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 function L({
   illustrationColor: t
 }) {

package/dist/{Birthday-DGKQY2Hx.mjs → Birthday-Da5KiZzO.mjs}

@@ -1,4 +1,4 @@
-import { j as c } from "./reactComponent-pXnU2FiB.mjs";
+import { j as c } from "./reactComponent-D3nRHRjE.mjs";
 const n = ({ variant: t }) => s[t] || s.regular, s = {
   thin: void 0,
   regular: /* @__PURE__ */ c.jsxs(c.Fragment, { children: [

package/dist/{BrandPromise-DOr56Gcn.mjs → BrandPromise-jU9IJWgw.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 function i({
   illustrationColor: L
 }) {

package/dist/{BrandVision-D9oLw77o.mjs → BrandVision-CI-lMTGG.mjs}

@@ -1,4 +1,4 @@
-import { j as C } from "./reactComponent-pXnU2FiB.mjs";
+import { j as C } from "./reactComponent-D3nRHRjE.mjs";
 function l({
   illustrationColor: i
 }) {

package/dist/{BubbleGraph-BnqnX08u.mjs → BubbleGraph-BjlKc4fH.mjs}

@@ -1,4 +1,4 @@
-import { j as r } from "./reactComponent-pXnU2FiB.mjs";
+import { j as r } from "./reactComponent-D3nRHRjE.mjs";
 const s = ({ color: c }) => /* @__PURE__ */ r.jsxs(r.Fragment, { children: [
   /* @__PURE__ */ r.jsx("circle", { cx: "21.3438", cy: "42.6465", r: "21.3438", fill: c }),
   /* @__PURE__ */ r.jsx("circle", { cx: "50.5938", cy: "13.3333", r: "13.3333", fill: c })

package/dist/{Calendar-nnjwsOOj.mjs → Calendar-BiRBpnSX.mjs}

@@ -1,4 +1,4 @@
-import { j as c } from "./reactComponent-pXnU2FiB.mjs";
+import { j as c } from "./reactComponent-D3nRHRjE.mjs";
 const e = ({ variant: s }) => t[s] || t.regular, t = {
   thin: void 0,
   regular: /* @__PURE__ */ c.jsxs(c.Fragment, { children: [

package/dist/{CaretDn-_j4E1zC6.mjs → CaretDn-CmjKXpG0.mjs}

@@ -1,4 +1,4 @@
-import { j as t } from "./reactComponent-pXnU2FiB.mjs";
+import { j as t } from "./reactComponent-D3nRHRjE.mjs";
 const o = () => /* @__PURE__ */ t.jsx(
   "path",
   {