@worktango/ai-assistant 0.0.1 → 0.0.2-beta-gd2

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/constants.js

@@ -0,0 +1,80 @@
+/**
+ * This file contains constants for the WorkTango Coach AI Assistant. It should
+ * contain no imports or dependencies: just constants and JSDoc types.
+ *
+ * We use it for sharing prompts and other data between systems in as light a way
+ * as possible.
+ */
+
+export const workTangoCoachSystemInstruction = `You are a 'Leadership Coach'. Your purpose is to empower People Leaders by providing guidance, resources, and tools to enhance their leadership capabilities. You will assist users in various aspects of leadership development, from problem-solving to goal setting and self-reflection. Sometimes you will be tasked with analyzing Survey Results. The Survey Results will inform the Coaching focus.
+
+Purpose and Goals:
+
+* **Guidance and Research:** Help users research and understand effective approaches to specific leadership challenges, issues, or topics.
+* **Self-Assessment Support:** Assist users in conducting self-assessments to identify their strengths, weaknesses, and areas for development as leaders.
+* **Goal Setting Facilitation:** Guide users through the process of setting clear, actionable, and measurable leadership goals.
+* **Reflective Questioning:** Engage users in reflective exercises using 'Powerful Questions' to encourage introspection and deeper understanding of their leadership journey.
+* **Knowledge Transfer:** Educate users on leadership theories, best practices, and effective strategies for leading teams and organizations.
+
+Behaviors and Rules:
+
+**Initial Engagement:**
+- If asked about something specific, you can skip the formal introduction, otherwise:
+- Greet the user warmly as their 'Leadership Coach' and express readiness to assist them in their growth as a Leader
+- List common requests you're designed to handle (research, self-assessment, goal setting, reflection, teaching).
+- Indicate that the session will be 5-10 mins
+- Ask the user to specify which of these areas they'd like to focus on first, or if they have a different leadership challenge in mind.
+
+**Interactive Support:**
+
+- For research requests, ask clarifying questions to understand the specific challenge or topic, then provide concise, actionable insights or resources.
+- For self-assessment, present frameworks or prompts, and encourage the user to share their thoughts, offering constructive feedback.
+- For goal setting, help the user define SMART (Specific, - Measurable, Achievable, Relevant, Time-bound) goals, breaking them down into manageable steps.
+- When using 'Powerful Questions', pose open-ended, thought-provoking questions that encourage deep reflection rather than simple 'yes/no' answers.
+- When teaching, break down complex concepts into understandable segments, providing examples and real-world applications.
+
+**Coaching Approach:**
+
+- Aim for a 5-10 minute coaching session
+- Maintain a supportive, encouraging, and non-judgmental demeanor.
+- Propose paths forward and look for input on the relevance of what is being suggested
+- Encourage active participation and critical thinking from the user.
+- Keep responses concise and clear, generally within 2-3 sentences per turn, allowing for a dynamic conversation flow.
+- Always end the conversation with a summary of the discussions and recommended actions for the People Leader
+
+Overall Tone:
+
+* **Empowering and Positive:** Foster a sense of capability and growth in the user.
+* **Knowledgeable and Trustworthy:** Convey expertise in leadership principles and practices.
+* **Patient and Understanding:** Recognize the complexities of leadership and support users through their challenges.
+* **Action-Oriented:** Encourage practical application of learned concepts.
+`;
+
+/**
+ * @typedef {Object} AiAssistantSuggestedPrompt
+ * @property {string} title - The title of the suggested prompt.
+ * @property {string} [fullPrompt] - The full prompt to be used. If not provided, the title will be used as the prompt.
+ */
+
+/**
+ * Globally-available suggested prompts used between platforms.
+ * @type {AiAssistantSuggestedPrompt[]}
+ */
+export const workTangoCoachGlobalSuggestedPrompts = [
+  {
+    title:
+      "Help me research how to approach a specific challenge, issue or topic",
+  },
+  { title: "Help me set effective goals for my team" },
+  { title: "Help me structure better 1-on-1s with my team" },
+  { title: "Help me reflect with powerful questions" },
+  { title: "Help me have a difficult conversation with a team member" },
+  { title: "Help me delegate more effectively" },
+  { title: "Help me with a self assessment" },
+  {
+    title: "How do I adapt my leadership approach to different personalities?",
+  },
+  { title: "How do I keep my team motivated during a crunch period?" },
+  { title: "How do I make space for strategic thinking amid daily fires?" },
+  { title: "How can I communicate a tough change to my team with empathy?" },
+];

package/dist/Absenteeism-DnYRfCGD.mjs

@@ -0,0 +1,49 @@
+import { j as C } from "./reactComponent-CGfCiP84.mjs";
+function e({
+  illustrationColor: t
+}) {
+  return /* @__PURE__ */ C.jsxs(C.Fragment, { children: [
+    /* @__PURE__ */ C.jsx("title", { children: "Absenteeism illustration" }),
+    /* @__PURE__ */ C.jsx(
+      "path",
+      {
+        d: "M60 120C93.1371 120 120 93.1371 120 60C120 26.8629 93.1371 0 60 0C26.8629 0 0 26.8629 0 60C0 93.1371 26.8629 120 60 120Z",
+        fill: t
+      }
+    ),
+    /* @__PURE__ */ C.jsx(
+      "path",
+      {
+        d: "M26.0354 50.0576V89.2332C26.0368 90.4902 26.5367 91.6953 27.4256 92.5842C28.3144 93.473 29.5195 93.9729 30.7765 93.9743H89.2541C90.5111 93.9729 91.7162 93.473 92.6051 92.5842C93.4939 91.6953 93.9938 90.4902 93.9952 89.2332V50.0576H26.0354ZM72.6461 81.3799C72.9411 81.6955 73.102 82.1133 73.0947 82.5452C73.0875 82.9771 72.9127 83.3893 72.6072 83.6947C72.3018 84.0002 71.8896 84.175 71.4577 84.1822C71.0258 84.1895 70.6079 84.0286 70.2924 83.7336L60.6959 74.1345L51.0839 83.7336C50.9313 83.8968 50.7475 84.0276 50.5433 84.1182C50.3392 84.2089 50.1188 84.2575 49.8955 84.2613C49.6721 84.265 49.4503 84.2238 49.2432 84.14C49.0361 84.0563 48.848 83.9317 48.6901 83.7738C48.5321 83.6158 48.4075 83.4277 48.3238 83.2206C48.24 83.0135 48.1988 82.7917 48.2026 82.5683C48.2063 82.345 48.255 82.1247 48.3456 81.9205C48.4363 81.7163 48.5671 81.5325 48.7302 81.3799L58.3293 71.7809L48.7458 62.1844C48.5827 62.0318 48.4518 61.848 48.3612 61.6438C48.2705 61.4397 48.2219 61.2193 48.2181 60.996C48.2144 60.7726 48.2556 60.5508 48.3394 60.3437C48.4231 60.1366 48.5477 59.9485 48.7056 59.7906C48.8636 59.6326 49.0517 59.508 49.2588 59.4243C49.4659 59.3405 49.6877 59.2993 49.9111 59.303C50.1344 59.3068 50.3548 59.3555 50.5589 59.4461C50.7631 59.5368 50.9469 59.6676 51.0995 59.8307L60.6959 69.4298L70.295 59.8307C70.4476 59.6676 70.6314 59.5368 70.8356 59.4461C71.0397 59.3555 71.2601 59.3068 71.4834 59.303C71.7068 59.2993 71.9286 59.3405 72.1357 59.4243C72.3428 59.508 72.5309 59.6326 72.6889 59.7906C72.8468 59.9485 72.9714 60.1366 73.0551 60.3437C73.1389 60.5508 73.1801 60.7726 73.1764 60.996C73.1726 61.2193 73.124 61.4397 73.0333 61.6438C72.9426 61.848 72.8118 62.0318 72.6487 62.1844L63.034 71.7809L72.6461 81.3799Z",
+        fill: "white"
+      }
+    ),
+    /* @__PURE__ */ C.jsx(
+      "path",
+      {
+        opacity: "0.4",
+        d: "M89.2248 33.0134H80.7376V39.7081C80.7376 40.3144 80.4968 40.8959 80.068 41.3246C79.6393 41.7533 79.0578 41.9942 78.4515 41.9942C77.8452 41.9942 77.2637 41.7533 76.835 41.3246C76.4063 40.8959 76.1654 40.3144 76.1654 39.7081V33.0134H43.8092V39.7081C43.8092 40.3144 43.5683 40.8959 43.1396 41.3246C42.7108 41.7533 42.1294 41.9942 41.523 41.9942C40.9167 41.9942 40.3353 41.7533 39.9065 41.3246C39.4778 40.8959 39.2369 40.3144 39.2369 39.7081V33.0134H30.7446C29.4876 33.0148 28.2825 33.5148 27.3936 34.4036C26.5048 35.2924 26.0049 36.4975 26.0035 37.7545V46.7379H93.9633V37.7545C93.9626 36.4978 93.4632 35.2926 92.5748 34.4037C91.6864 33.5148 90.4816 33.0148 89.2248 33.0134V33.0134Z",
+        fill: "black"
+      }
+    ),
+    /* @__PURE__ */ C.jsx(
+      "path",
+      {
+        opacity: "0.7",
+        d: "M41.5184 41.3705C41.0774 41.3705 40.6545 41.1953 40.3427 40.8835C40.0309 40.5717 39.8558 40.1488 39.8558 39.7079V27.6824C39.8558 27.2414 40.0309 26.8185 40.3427 26.5067C40.6545 26.1949 41.0774 26.0198 41.5184 26.0198C41.9594 26.0198 42.3823 26.1949 42.6941 26.5067C43.0059 26.8185 43.181 27.2414 43.181 27.6824V39.7079C43.1803 40.1486 43.0049 40.5711 42.6933 40.8828C42.3816 41.1944 41.9591 41.3698 41.5184 41.3705V41.3705Z",
+        fill: "white"
+      }
+    ),
+    /* @__PURE__ */ C.jsx(
+      "path",
+      {
+        opacity: "0.7",
+        d: "M78.4519 41.3705C78.0111 41.3698 77.5886 41.1944 77.277 40.8828C76.9653 40.5711 76.7899 40.1486 76.7892 39.7079V27.6824C76.7892 27.2414 76.9644 26.8185 77.2762 26.5067C77.588 26.1949 78.0109 26.0198 78.4519 26.0198C78.8928 26.0198 79.3157 26.1949 79.6275 26.5067C79.9393 26.8185 80.1145 27.2414 80.1145 27.6824V39.7079C80.1138 40.1486 79.9384 40.5711 79.6268 40.8828C79.3151 41.1944 78.8926 41.3698 78.4519 41.3705V41.3705Z",
+        fill: "white"
+      }
+    )
+  ] });
+}
+export {
+  e as Absenteeism
+};