@uipath/apollo-react 3.44.1 → 3.44.2-pr255.af80ea0

package/dist/canvas/core/useTaskTypeRegistry.cjs

@@ -0,0 +1,82 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useTaskTypeRegistry: ()=>useTaskTypeRegistry,
+    TaskRegistryContext: ()=>TaskRegistryContext,
+    useTaskManifest: ()=>useTaskManifest,
+    useTaskManifests: ()=>useTaskManifests,
+    useOptionalTaskTypeRegistry: ()=>useOptionalTaskTypeRegistry,
+    useIsTaskAllowedInStage: ()=>useIsTaskAllowedInStage
+});
+const external_react_namespaceObject = require("react");
+const TaskRegistryContext = (0, external_react_namespaceObject.createContext)(null);
+const useTaskTypeRegistry = ()=>{
+    const context = (0, external_react_namespaceObject.useContext)(TaskRegistryContext);
+    if (!context) throw new Error('useTaskTypeRegistry must be used within a TaskRegistryProvider');
+    return context.registry;
+};
+const useOptionalTaskTypeRegistry = ()=>{
+    const context = (0, external_react_namespaceObject.useContext)(TaskRegistryContext);
+    return context?.registry ?? null;
+};
+const useTaskManifests = ()=>{
+    const registry = useTaskTypeRegistry();
+    return (0, external_react_namespaceObject.useMemo)(()=>registry.getAllManifests(), [
+        registry
+    ]);
+};
+const useTaskManifest = (taskType)=>{
+    const registry = useTaskTypeRegistry();
+    return (0, external_react_namespaceObject.useMemo)(()=>registry.getManifest(taskType), [
+        registry,
+        taskType
+    ]);
+};
+const useIsTaskAllowedInStage = (taskType, stageNodeType)=>{
+    const registry = useTaskTypeRegistry();
+    return (0, external_react_namespaceObject.useMemo)(()=>registry.isTaskAllowedInStage(taskType, stageNodeType), [
+        registry,
+        taskType,
+        stageNodeType
+    ]);
+};
+exports.TaskRegistryContext = __webpack_exports__.TaskRegistryContext;
+exports.useIsTaskAllowedInStage = __webpack_exports__.useIsTaskAllowedInStage;
+exports.useOptionalTaskTypeRegistry = __webpack_exports__.useOptionalTaskTypeRegistry;
+exports.useTaskManifest = __webpack_exports__.useTaskManifest;
+exports.useTaskManifests = __webpack_exports__.useTaskManifests;
+exports.useTaskTypeRegistry = __webpack_exports__.useTaskTypeRegistry;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "TaskRegistryContext",
+    "useIsTaskAllowedInStage",
+    "useOptionalTaskTypeRegistry",
+    "useTaskManifest",
+    "useTaskManifests",
+    "useTaskTypeRegistry"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/core/useTaskTypeRegistry.d.ts

@@ -0,0 +1,13 @@
+import type { TaskManifest } from '../schema/task-definition';
+import type { TaskTypeRegistry } from './TaskTypeRegistry';
+interface TaskRegistryContextValue {
+    registry: TaskTypeRegistry;
+}
+export declare const TaskRegistryContext: import("react").Context<TaskRegistryContextValue | null>;
+export declare const useTaskTypeRegistry: () => TaskTypeRegistry;
+export declare const useOptionalTaskTypeRegistry: () => TaskTypeRegistry | null;
+export declare const useTaskManifests: () => TaskManifest[];
+export declare const useTaskManifest: (taskType: string) => TaskManifest | undefined;
+export declare const useIsTaskAllowedInStage: (taskType: string, stageNodeType: string) => boolean;
+export {};
+//# sourceMappingURL=useTaskTypeRegistry.d.ts.map

package/dist/canvas/core/useTaskTypeRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTaskTypeRegistry.d.ts","sourceRoot":"","sources":["../../../src/canvas/core/useTaskTypeRegistry.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,UAAU,wBAAwB;IAChC,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,eAAO,MAAM,mBAAmB,0DAAuD,CAAC;AAOxF,eAAO,MAAM,mBAAmB,QAAO,gBAMtC,CAAC;AAMF,eAAO,MAAM,2BAA2B,QAAO,gBAAgB,GAAG,IAGjE,CAAC;AAMF,eAAO,MAAM,gBAAgB,QAAO,YAAY,EAG/C,CAAC;AAOF,eAAO,MAAM,eAAe,GAAI,UAAU,MAAM,KAAG,YAAY,GAAG,SAGjE,CAAC;AAQF,eAAO,MAAM,uBAAuB,GAClC,UAAU,MAAM,EAChB,eAAe,MAAM,KACpB,OAMF,CAAC"}

package/dist/canvas/core/useTaskTypeRegistry.js

@@ -0,0 +1,33 @@
+import { createContext, useContext, useMemo } from "react";
+const TaskRegistryContext = createContext(null);
+const useTaskTypeRegistry = ()=>{
+    const context = useContext(TaskRegistryContext);
+    if (!context) throw new Error('useTaskTypeRegistry must be used within a TaskRegistryProvider');
+    return context.registry;
+};
+const useOptionalTaskTypeRegistry = ()=>{
+    const context = useContext(TaskRegistryContext);
+    return context?.registry ?? null;
+};
+const useTaskManifests = ()=>{
+    const registry = useTaskTypeRegistry();
+    return useMemo(()=>registry.getAllManifests(), [
+        registry
+    ]);
+};
+const useTaskManifest = (taskType)=>{
+    const registry = useTaskTypeRegistry();
+    return useMemo(()=>registry.getManifest(taskType), [
+        registry,
+        taskType
+    ]);
+};
+const useIsTaskAllowedInStage = (taskType, stageNodeType)=>{
+    const registry = useTaskTypeRegistry();
+    return useMemo(()=>registry.isTaskAllowedInStage(taskType, stageNodeType), [
+        registry,
+        taskType,
+        stageNodeType
+    ]);
+};
+export { TaskRegistryContext, useIsTaskAllowedInStage, useOptionalTaskTypeRegistry, useTaskManifest, useTaskManifests, useTaskTypeRegistry };

package/dist/canvas/hooks/CrossStageDragContext.cjs

@@ -0,0 +1,45 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    useCrossStageDragState: ()=>useCrossStageDragState,
+    CrossStageDragProvider: ()=>CrossStageDragProvider
+});
+const external_react_namespaceObject = require("react");
+const CrossStageDragContext = /*#__PURE__*/ (0, external_react_namespaceObject.createContext)(null);
+const CrossStageDragProvider = CrossStageDragContext.Provider;
+function useCrossStageDragState() {
+    const context = (0, external_react_namespaceObject.useContext)(CrossStageDragContext);
+    return context?.dragState ?? null;
+}
+exports.CrossStageDragProvider = __webpack_exports__.CrossStageDragProvider;
+exports.useCrossStageDragState = __webpack_exports__.useCrossStageDragState;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "CrossStageDragProvider",
+    "useCrossStageDragState"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/hooks/CrossStageDragContext.d.ts

@@ -0,0 +1,8 @@
+import type { CrossStageDragState } from './useCrossStageTaskDrag';
+interface CrossStageDragContextValue {
+    dragState: CrossStageDragState;
+}
+export declare const CrossStageDragProvider: import("react").Provider<CrossStageDragContextValue | null>;
+export declare function useCrossStageDragState(): CrossStageDragState | null;
+export {};
+//# sourceMappingURL=CrossStageDragContext.d.ts.map

package/dist/canvas/hooks/CrossStageDragContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CrossStageDragContext.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/CrossStageDragContext.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,UAAU,0BAA0B;IAClC,SAAS,EAAE,mBAAmB,CAAC;CAChC;AAID,eAAO,MAAM,sBAAsB,6DAAiC,CAAC;AAErE,wBAAgB,sBAAsB,IAAI,mBAAmB,GAAG,IAAI,CAGnE"}

package/dist/canvas/hooks/CrossStageDragContext.js

@@ -0,0 +1,8 @@
+import { createContext, useContext } from "react";
+const CrossStageDragContext = /*#__PURE__*/ createContext(null);
+const CrossStageDragProvider = CrossStageDragContext.Provider;
+function useCrossStageDragState() {
+    const context = useContext(CrossStageDragContext);
+    return context?.dragState ?? null;
+}
+export { CrossStageDragProvider, useCrossStageDragState };

package/dist/canvas/hooks/calculateTaskDropPosition.cjs

@@ -0,0 +1,253 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    calculateDropPosition: ()=>calculateDropPosition,
+    convertToGroupPosition: ()=>convertToGroupPosition
+});
+const useTaskPositions_cjs_namespaceObject = require("../components/TaskNode/useTaskPositions.cjs");
+function getTaskBottom(flatIndex, taskIds) {
+    const config = useTaskPositions_cjs_namespaceObject.DEFAULT_TASK_POSITION_CONFIG;
+    let currentY = config.contentPaddingTop;
+    let currentIndex = 0;
+    for (const group of taskIds){
+        for(let i = 0; i < group.length; i++){
+            if (currentIndex === flatIndex) return currentY + config.taskHeight;
+            currentY += config.taskHeight;
+            if (i < group.length - 1) currentY += config.taskGap;
+            currentIndex++;
+        }
+        currentY += config.taskGap;
+    }
+    return currentY;
+}
+function getTaskTop(flatIndex, taskIds) {
+    const config = useTaskPositions_cjs_namespaceObject.DEFAULT_TASK_POSITION_CONFIG;
+    let currentY = config.contentPaddingTop;
+    let currentIndex = 0;
+    for (const group of taskIds){
+        for(let i = 0; i < group.length; i++){
+            if (currentIndex === flatIndex) return currentY;
+            currentY += config.taskHeight;
+            if (i < group.length - 1) currentY += config.taskGap;
+            currentIndex++;
+        }
+        currentY += config.taskGap;
+    }
+    return currentY;
+}
+function getTotalTaskCount(taskIds) {
+    return taskIds.reduce((sum, group)=>sum + group.length, 0);
+}
+function isIndexInParallelGroup(flatIndex, taskIds) {
+    let currentIndex = 0;
+    for (const group of taskIds)for(let taskIndex = 0; taskIndex < group.length; taskIndex++){
+        if (currentIndex === flatIndex) return group.length > 1;
+        currentIndex++;
+    }
+    return false;
+}
+function isAtParallelGroupEdge(flatIndex, taskIds) {
+    let currentIndex = 0;
+    for (const group of taskIds)for(let taskIndex = 0; taskIndex < group.length; taskIndex++){
+        if (currentIndex === flatIndex) {
+            if (group.length <= 1) return false;
+            return 0 === taskIndex || taskIndex === group.length - 1;
+        }
+        currentIndex++;
+    }
+    return false;
+}
+function calculateDropPosition(nodeY, nodeHeight, nodeX, nodeWidth, stageWidth, taskIds, draggedTaskId) {
+    const config = useTaskPositions_cjs_namespaceObject.DEFAULT_TASK_POSITION_CONFIG;
+    const halfTaskGap = config.taskGap / 2;
+    const filteredTaskIds = taskIds.map((group)=>group.filter((id)=>id !== draggedTaskId)).filter((group)=>group.length > 0);
+    const totalTasks = getTotalTaskCount(filteredTaskIds);
+    const PY = nodeY - config.headerHeight + nodeHeight / 2;
+    const PX = nodeX + nodeWidth / 2;
+    let index = 0;
+    if (0 === totalTasks) index = 0;
+    else {
+        const bottomOfFirst = getTaskBottom(0, filteredTaskIds);
+        if (PY <= bottomOfFirst + halfTaskGap) index = 0;
+        else {
+            const lastIndex = totalTasks - 1;
+            const bottomOfLast = getTaskBottom(lastIndex, filteredTaskIds);
+            if (PY > bottomOfLast + halfTaskGap) index = totalTasks;
+            else for(let n = 1; n < totalTasks; n++){
+                const bottomOfPrev = getTaskBottom(n - 1, filteredTaskIds);
+                const bottomOfCurrent = getTaskBottom(n, filteredTaskIds);
+                if (PY > bottomOfPrev + halfTaskGap && PY <= bottomOfCurrent + halfTaskGap) {
+                    index = n;
+                    break;
+                }
+            }
+        }
+    }
+    const inParallelGroup = isIndexInParallelGroup(index, filteredTaskIds);
+    const isLeftHalf = PX < stageWidth / 2;
+    const wasOriginalGroupParallel = (filteredGroupIndex)=>{
+        if (filteredGroupIndex < 0 || filteredGroupIndex >= filteredTaskIds.length) return false;
+        const filteredGroup = filteredTaskIds[filteredGroupIndex];
+        if (!filteredGroup || 0 === filteredGroup.length) return false;
+        const firstTaskId = filteredGroup[0];
+        for (const originalGroup of taskIds)if (originalGroup.includes(firstTaskId)) return originalGroup.length > 1;
+        return false;
+    };
+    const getGroupAndTaskIndex = (flatIndex)=>{
+        let currentIndex = 0;
+        for(let gi = 0; gi < filteredTaskIds.length; gi++){
+            const group = filteredTaskIds[gi];
+            if (group) {
+                if (currentIndex + group.length > flatIndex) return {
+                    groupIndex: gi,
+                    taskIndex: flatIndex - currentIndex
+                };
+                currentIndex += group.length;
+            }
+        }
+        return null;
+    };
+    let isParallel = false;
+    if (inParallelGroup) {
+        const atEdge = isAtParallelGroupEdge(index, filteredTaskIds);
+        isParallel = !(atEdge && isLeftHalf);
+    } else if (index >= totalTasks && filteredTaskIds.length > 0) {
+        const lastFilteredGroup = filteredTaskIds[filteredTaskIds.length - 1];
+        const lastGroupWasParallel = wasOriginalGroupParallel(filteredTaskIds.length - 1);
+        if (lastFilteredGroup && lastGroupWasParallel && !isLeftHalf) isParallel = true;
+    } else if (!inParallelGroup && index < totalTasks) {
+        const posInfo = getGroupAndTaskIndex(index);
+        if (posInfo) {
+            const { groupIndex, taskIndex } = posInfo;
+            if (wasOriginalGroupParallel(groupIndex) && !isLeftHalf) isParallel = true;
+            else if (0 === taskIndex && groupIndex > 0) {
+                const currentGroup = filteredTaskIds[groupIndex];
+                const prevGroupWasParallel = wasOriginalGroupParallel(groupIndex - 1);
+                if (currentGroup && 1 === currentGroup.length && prevGroupWasParallel && !isLeftHalf) isParallel = true;
+            }
+        }
+    }
+    return {
+        index,
+        isParallel,
+        draggedYCenter: PY
+    };
+}
+function getTaskYCenter(flatIndex, taskIds) {
+    const top = getTaskTop(flatIndex, taskIds);
+    return top + useTaskPositions_cjs_namespaceObject.DEFAULT_TASK_POSITION_CONFIG.taskHeight / 2;
+}
+function getGroupInfoAtIndex(flatIndex, taskIds) {
+    let currentIndex = 0;
+    for(let groupIndex = 0; groupIndex < taskIds.length; groupIndex++){
+        const group = taskIds[groupIndex];
+        if (group) for(let taskIndex = 0; taskIndex < group.length; taskIndex++){
+            if (currentIndex === flatIndex) return {
+                groupIndex,
+                taskIndex,
+                isFirstInGroup: 0 === taskIndex
+            };
+            currentIndex++;
+        }
+    }
+    return null;
+}
+function convertToGroupPosition(index, isParallel, taskIds, draggedYCenter, originalTaskIds) {
+    if (0 === taskIds.length) return {
+        groupIndex: 0,
+        taskIndex: 0
+    };
+    const wasOriginallyParallel = (filteredGroupIndex)=>{
+        if (!originalTaskIds || filteredGroupIndex < 0 || filteredGroupIndex >= taskIds.length) return false;
+        const filteredGroup = taskIds[filteredGroupIndex];
+        if (!filteredGroup || 0 === filteredGroup.length) return false;
+        if (filteredGroup.length > 1) return true;
+        const firstTaskId = filteredGroup[0];
+        for (const originalGroup of originalTaskIds)if (originalGroup.includes(firstTaskId)) return originalGroup.length > 1;
+        return false;
+    };
+    const groupInfo = getGroupInfoAtIndex(index, taskIds);
+    if (groupInfo) {
+        const { groupIndex, taskIndex, isFirstInGroup } = groupInfo;
+        if (!isParallel) return {
+            groupIndex,
+            taskIndex: 0
+        };
+        {
+            const currentGroup = taskIds[groupIndex];
+            const currentGroupIsSequential = currentGroup && 1 === currentGroup.length;
+            const currentGroupWasParallel = wasOriginallyParallel(groupIndex);
+            if (currentGroupIsSequential && currentGroupWasParallel) return {
+                groupIndex,
+                taskIndex
+            };
+            if (isFirstInGroup && groupIndex > 0 && currentGroupIsSequential && !currentGroupWasParallel) {
+                const prevGroup = taskIds[groupIndex - 1];
+                const prevGroupWasParallel = wasOriginallyParallel(groupIndex - 1);
+                if (prevGroup && (prevGroup.length > 1 || prevGroupWasParallel)) return {
+                    groupIndex: groupIndex - 1,
+                    taskIndex: prevGroup.length
+                };
+            }
+            if (isFirstInGroup && groupIndex > 0 && !currentGroupIsSequential && void 0 !== draggedYCenter) {
+                const prevGroup = taskIds[groupIndex - 1];
+                const prevGroupWasParallel = wasOriginallyParallel(groupIndex - 1);
+                if (prevGroup && (prevGroup.length > 1 || prevGroupWasParallel)) {
+                    const placeholderYCenter = getTaskYCenter(index, taskIds);
+                    if (draggedYCenter < placeholderYCenter) return {
+                        groupIndex: groupIndex - 1,
+                        taskIndex: prevGroup.length
+                    };
+                }
+            }
+            return {
+                groupIndex,
+                taskIndex
+            };
+        }
+    }
+    if (isParallel && taskIds.length > 0) {
+        const lastGroup = taskIds[taskIds.length - 1];
+        const lastGroupWasParallel = wasOriginallyParallel(taskIds.length - 1);
+        if (lastGroup && (lastGroup.length > 1 || lastGroupWasParallel)) return {
+            groupIndex: taskIds.length - 1,
+            taskIndex: lastGroup.length
+        };
+    }
+    return {
+        groupIndex: taskIds.length,
+        taskIndex: 0
+    };
+}
+exports.calculateDropPosition = __webpack_exports__.calculateDropPosition;
+exports.convertToGroupPosition = __webpack_exports__.convertToGroupPosition;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "calculateDropPosition",
+    "convertToGroupPosition"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/canvas/hooks/calculateTaskDropPosition.d.ts

@@ -0,0 +1,11 @@
+export interface DropPosition {
+    index: number;
+    isParallel: boolean;
+    draggedYCenter: number;
+}
+export declare function calculateDropPosition(nodeY: number, nodeHeight: number, nodeX: number, nodeWidth: number, stageWidth: number, taskIds: string[][], draggedTaskId: string): DropPosition;
+export declare function convertToGroupPosition(index: number, isParallel: boolean, taskIds: string[][], draggedYCenter?: number, originalTaskIds?: string[][]): {
+    groupIndex: number;
+    taskIndex: number;
+};
+//# sourceMappingURL=calculateTaskDropPosition.d.ts.map

package/dist/canvas/hooks/calculateTaskDropPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateTaskDropPosition.d.ts","sourceRoot":"","sources":["../../../src/canvas/hooks/calculateTaskDropPosition.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,YAAY;IAE3B,KAAK,EAAE,MAAM,CAAC;IAEd,UAAU,EAAE,OAAO,CAAC;IAEpB,cAAc,EAAE,MAAM,CAAC;CACxB;AA+GD,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,aAAa,EAAE,MAAM,GACpB,YAAY,CA4Hd;AA4CD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,MAAM,EAAE,EAAE,EACnB,cAAc,CAAC,EAAE,MAAM,EACvB,eAAe,CAAC,EAAE,MAAM,EAAE,EAAE,GAC3B;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAuF3C"}