@pristy/pristy-libvue 2.21.2 → 3.1.0

package/dist/stores/indexAwait.d.ts

@@ -0,0 +1,83 @@
+import { StoreDefinition, PiniaCustomStateProperties } from 'pinia';
+export const INDEX_AWAIT_PHASE: Readonly<{
+    IDLE: "idle";
+    WAITING: "waiting";
+    SLOW: "slow";
+}>;
+export const useIndexAwaitStore: StoreDefinition<"indexAwait", {
+    phase: "idle";
+    done: number;
+    total: number;
+}, {
+    visible: (state: {
+        phase: "idle";
+        done: number;
+        total: number;
+    } & PiniaCustomStateProperties<{
+        phase: "idle";
+        done: number;
+        total: number;
+    }>) => boolean;
+    isSlow: (state: {
+        phase: "idle";
+        done: number;
+        total: number;
+    } & PiniaCustomStateProperties<{
+        phase: "idle";
+        done: number;
+        total: number;
+    }>) => boolean;
+}, {
+    /**
+     * Waits until nodes just changed are searchable, then reruns the page's
+     * query. See `docs/IndexAwait.md` for the decision table.
+     *
+     * @param {string[]} nodeIds
+     * @param {{listingSource?: string, onRefresh?: Function, onUnavailable?: Function, refreshOnDone?: boolean, timeout?: number, background?: boolean}} [options]
+     * @returns {Promise<{status: string, searchable: string[], errors: Array<Object>, rejected: string[], pending: string[]}>}
+     *   never rejects; `status` is `skipped`, `done`, `timeout`, `unavailable` or `background`
+     */
+    waitFor(nodeIds: string[], { listingSource, onRefresh, onUnavailable, refreshOnDone, timeout, background, }?: {
+        listingSource?: string;
+        onRefresh?: Function;
+        onUnavailable?: Function;
+        refreshOnDone?: boolean;
+        timeout?: number;
+        background?: boolean;
+    }): Promise<{
+        status: string;
+        searchable: string[];
+        errors: Array<any>;
+        rejected: string[];
+        pending: string[];
+    }>;
+    beginWait(ids: any, background: any, resolve: any): {
+        id: any;
+        ids: any;
+        done: number;
+        total: any;
+        background: any;
+        backgroundFromStart: any;
+        resolve: any;
+    };
+    updateWait(waitId: any, done: any): void;
+    settleWait(wait: any, result: any, { onRefresh, onUnavailable, refreshOnDone }: {
+        onRefresh: any;
+        onUnavailable: any;
+        refreshOnDone: any;
+    }): Promise<void>;
+    endWait(waitId: any): void;
+    syncProgress(): void;
+    /**
+     * Hides the slow message and reruns the query of the page that waited.
+     *
+     * @returns {Promise<void>}
+     */
+    reload(): Promise<void>;
+    /**
+     * Closes the overlay: every running wait goes on in the background and
+     * refreshes its page silently when it ends.
+     */
+    dismiss(): void;
+}>;
+//# sourceMappingURL=indexAwait.d.ts.map

package/dist/stores/indexAwait.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexAwait.d.ts","sourceRoot":"","sources":["../../src/stores/indexAwait.js"],"names":[],"mappings":";AAwBA;;;;GAIG;AAkCH;;;;;;;;;;;;;;;;;;;;;;;;IAWI;;;;;;;;OAQG;qBAJQ,MAAM,EAAE,qFACR;QAAC,aAAa,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,WAAW;QAAC,aAAa,CAAC,WAAW;QAAC,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAC,GACvI,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,KAAK,KAAQ,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC;;;;;;;;;;;;;;;;;;IAwI1H;;;;OAIG;cADU,OAAO,CAAC,IAAI,CAAC;IAQ1B;;;OAGG;;GAWJ"}

package/dist/stores/markdownDocument.d.ts

@@ -0,0 +1,30 @@
+import { StoreDefinition, PiniaCustomStateProperties } from 'pinia';
+/**
+ * The Markdown document shown by `CodeMirrorEditor`, as it is being edited,
+ * and the heading another component asked it to show.
+ */
+export const useMarkdownDocumentStore: StoreDefinition<"MarkdownDocumentStore", {
+    nodeId: any;
+    content: string;
+    headingRequest: any;
+}, {
+    outline: (state: {
+        nodeId: any;
+        content: string;
+        headingRequest: any;
+    } & PiniaCustomStateProperties<{
+        nodeId: any;
+        content: string;
+        headingRequest: any;
+    }>) => {
+        index: number;
+        depth: number;
+        text: string;
+        line: number;
+    }[];
+}, {
+    setContent(nodeId: any, content: any): void;
+    clear(nodeId: any): void;
+    goToHeading(heading: any): void;
+}>;
+//# sourceMappingURL=markdownDocument.d.ts.map

package/dist/stores/markdownDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownDocument.d.ts","sourceRoot":"","sources":["../../src/stores/markdownDocument.js"],"names":[],"mappings":";AAmBA;;;GAGG;AACH;;;;;;;;;;;;;;;;;;;;;;;GA8BG"}

package/dist/stores/menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"menu.d.ts","sourceRoot":"","sources":["../../src/stores/menu.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;GAiBG;AACH,2BAZU,MAAM,CAyDb"}

package/dist/stores/navigation.d.ts

@@ -0,0 +1,89 @@
+import { StoreDefinition } from 'pinia';
+/**
+ * Store definition for managing the navigation state within a workspace or folder system.
+ * Provides state variables and actions to handle navigation-related functionality such as loading
+ * workspace data, managing nodes, folders, files, and handling user-specific behaviors.
+ *
+ * State Variables:
+ * - `currentNode`: The currently active node in the navigation hierarchy.
+ * - `totalRecordNodes`: The total number of record nodes available.
+ * - `workspace`: The current workspace object.
+ * - `workspaceInfo`: Additional information related to the workspace.
+ * - `nodes`: A list of nodes within the workspace or folder.
+ * - `files`: A list of file nodes present in the current view.
+ * - `folders`: A list of folder nodes present in the current view.
+ * - `children`: The immediate children of the current node.
+ * - `loading`: A boolean indicating if the application is in a loading state.
+ * - `emptyFolder`: A boolean indicating if the current folder is empty.
+ * - `role`: The user's role within the current workspace.
+ * - `canUpload`: A boolean indicating if the user has permission to upload.
+ * - `pagination`: Pagination details for managing viewable content.
+ * - `isInConsultation`: A boolean indicating if the user is in consultation mode.
+ * - `isInUserHome`: A boolean indicating if the user is in their home workspace.
+ * - `hasNoUserHome`: A boolean indicating if the user does not have a home workspace.
+ *
+ * Actions:
+ * - `setIsInUserHome(value)`: Updates the state to mark if the user is in their home workspace.
+ * - `setHasNoUserHome(value)`: Updates the state to mark if the user does not have a home workspace.
+ * - `load(workspaceId, folderId, force)`: Loads data for the current workspace and optionally for a folder.
+ * - `loadWithOpts(workspaceId, folderId, force, opts)`: Loads workspace data with additional options.
+ * - `loadOnActes(workspaceId, seanceId, force)`: Special loading logic for navigating in an "Actes" application context.
+ */
+export const useNavigationStore: StoreDefinition<"NavigationStore", {
+    currentNode: any;
+    totalRecordNodes: any;
+    workspace: any;
+    workspaceInfo: any;
+    nodes: any[];
+    files: any[];
+    folders: any[];
+    children: any[];
+    loading: boolean;
+    emptyFolder: boolean;
+    role: any;
+    canUpload: boolean;
+    pagination: any;
+    isInConsultation: boolean;
+    isInUserHome: boolean;
+    hasNoUserHome: boolean;
+}, {}, {
+    setIsInUserHome(value: any): void;
+    setHasNoUserHome(value: any): void;
+    /**
+     * Load children from current node (if it change)
+     * @param workspaceId Current Workspace id (mandatory)
+     * @param folderId Current Folder id (optional)
+     * @param force force load (reload) data
+     * @return Promise
+     */
+    load(workspaceId: any, folderId: any, force: any): Promise<void> | Promise<Node>;
+    /**
+     * Load a workspace or personal space folder and its children.
+     * Only the latest call writes the state: a call answered after a newer
+     * one started, or after a newer call found the state already current,
+     * changes nothing and resolves with `undefined`.
+     * @param workspaceId Current Workspace id, or null for the user home
+     * @param folderId Current Folder id (optional)
+     * @param force force load (reload) data
+     * @param opts options for getChildrenWithOpts
+     * @return {Promise<Object|undefined>} the folder node loaded
+     */
+    loadWithOpts(workspaceId: any, folderId: any, force: any, opts: any): Promise<any | undefined>;
+    /**
+     * Silently refresh children for ghost node polling.
+     * Does NOT set loading = true (no skeleton flash).
+     * Only updates state if the children IDs have actually changed.
+     * @param {Object} opts Options for getChildrenWithOpts
+     * @return {Promise}
+     */
+    silentRefreshChildren(opts: any): Promise<any>;
+    /**
+     * Load children from current node in Actes Application (if it change)
+     * @param workspaceId Current Workspace id (mandatory)
+     * @param seanceId Current seance id (optional)
+     * @param force force load (reload) data
+     * @return Promise
+     */
+    loadOnActes(workspaceId: any, seanceId: any, force: any): Promise<void> | Promise<Node>;
+}>;
+//# sourceMappingURL=navigation.d.ts.map

package/dist/stores/navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation.d.ts","sourceRoot":"","sources":["../../src/stores/navigation.js"],"names":[],"mappings":";AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;;;;;;;;;;;;;;;;;;;;IA2BI;;;;;;OAMG;;IAiEH;;;;;;;;;;OAUG;0EADS,OAAO,CAAC,MAAO,SAAS,CAAC;IA2FrC;;;;;;OAMG;;IA4BH;;;;;;OAMG;;GA4GJ"}

package/dist/stores/paginator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paginator.d.ts","sourceRoot":"","sources":["../../src/stores/paginator.js"],"names":[],"mappings":";AAkBA;;;;;;;;;;;;;;GAcG;AACH;;;;;GAYG"}

package/dist/stores/pdfDocument.d.ts

@@ -0,0 +1,89 @@
+import { StoreDefinition, PiniaCustomStateProperties } from 'pinia';
+/**
+ * The PDF shown by a `PDFComponent` given a `documentId`: its properties,
+ * its bookmarks, its signatures, its comments, whether it holds unsaved form
+ * values, the page another component asked it to show, the placement
+ * of a comment: a click awaited on a page, the point it gave, and the
+ * markers of the comments not saved yet, the text of each page, read
+ * once a component asked for it, the search run in it and the occurrences
+ * the viewer highlights.
+ */
+export const usePdfDocumentStore: StoreDefinition<"PdfDocumentStore", {
+    documentId: any;
+    loaded: boolean;
+    pageCount: number;
+    currentPage: number;
+    info: any;
+    outline: any[];
+    signatures: any[];
+    comments: any[];
+    commentsLoaded: boolean;
+    formDirty: boolean;
+    pageRequest: any;
+    placing: boolean;
+    placement: any;
+    markers: any[];
+    textRequested: boolean;
+    textLoaded: boolean;
+    pageTexts: any[];
+    searchQuery: string;
+    searchActive: any;
+    highlight: any;
+}, {
+    signed: (state: {
+        documentId: any;
+        loaded: boolean;
+        pageCount: number;
+        currentPage: number;
+        info: any;
+        outline: any[];
+        signatures: any[];
+        comments: any[];
+        commentsLoaded: boolean;
+        formDirty: boolean;
+        pageRequest: any;
+        placing: boolean;
+        placement: any;
+        markers: any[];
+        textRequested: boolean;
+        textLoaded: boolean;
+        pageTexts: any[];
+        searchQuery: string;
+        searchActive: any;
+        highlight: any;
+    } & PiniaCustomStateProperties<{
+        documentId: any;
+        loaded: boolean;
+        pageCount: number;
+        currentPage: number;
+        info: any;
+        outline: any[];
+        signatures: any[];
+        comments: any[];
+        commentsLoaded: boolean;
+        formDirty: boolean;
+        pageRequest: any;
+        placing: boolean;
+        placement: any;
+        markers: any[];
+        textRequested: boolean;
+        textLoaded: boolean;
+        pageTexts: any[];
+        searchQuery: string;
+        searchActive: any;
+        highlight: any;
+    }>) => boolean;
+}, {
+    publish(documentId: any, values: any): void;
+    clear(documentId: any): void;
+    startPlacement(): void;
+    cancelPlacement(): void;
+    place(point: any): void;
+    setMarkers(markers: any): void;
+    requestText(): void;
+    setSearchQuery(query: any): void;
+    selectOccurrence(index: any): void;
+    setHighlight(highlight: any): void;
+    goToPage(page: any): void;
+}>;
+//# sourceMappingURL=pdfDocument.d.ts.map

package/dist/stores/pdfDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pdfDocument.d.ts","sourceRoot":"","sources":["../../src/stores/pdfDocument.js"],"names":[],"mappings":";AAkBA;;;;;;;;GAQG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG"}

package/dist/stores/screen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"screen.d.ts","sourceRoot":"","sources":["../../src/stores/screen.js"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH,6BAFU,eAAe,CAAC,aAAa,EAAE;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,EAAE;IAAC,iBAAiB,EAAE,CAAC,CAAS,IAAC,EAAD,GAAC,KAAG,OAAO,CAAC,CAAC;IAAC,aAAa,EAAE,CAAC,CAAS,IAAC,EAAD,GAAC,KAAG,OAAO,CAAC,CAAC;IAAC,UAAU,EAAE,CAAC,CAAS,IAAC,EAAD,GAAC,KAAG,OAAO,CAAC,CAAA;CAAC,EAAE;IAAC,gBAAgB,IAAI,IAAI,CAAA;CAAC,CAAC,CAkBtO"}

package/dist/stores/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/stores/search.js"],"names":[],"mappings":";;AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuKI;;;;OAIG;2BAFe,KAAK,GACV,OAAO;;IA8BpB;;;;OAIG;qBAFe,KAAK,GACV,OAAO;;GAiBrB"}

package/dist/stores/selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/stores/selection.js"],"names":[],"mappings":";AAkBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;;;;;;;;IAaI;;;OAGG;;IAMH;;;OAGG;;IAMH;;;OAGG;;IAMH;;;OAGG;;IAUH;;;OAGG;;IAIH;;;OAGG;;GAKJ"}

package/dist/stores/taskNotification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskNotification.d.ts","sourceRoot":"","sources":["../../src/stores/taskNotification.js"],"names":[],"mappings":";AAuBA;;;;;;GAsCG"}

package/dist/stores/upload.d.ts

@@ -0,0 +1,174 @@
+import { StoreDefinition, PiniaCustomStateProperties } from 'pinia';
+export const useUploadStore: StoreDefinition<"upload", {
+    isUploading: boolean;
+    files: any[];
+    progress: {
+        completed: number;
+        total: number;
+    };
+    worker: any;
+    activeRequests: {};
+    classificationPlanFiles: any[];
+    onCompleteCallback: any;
+    pendingNodes: any[];
+    displayContext: any;
+    requalifyResolvedCounter: number;
+}, {
+    ghostContext(state: {
+        isUploading: boolean;
+        files: any[];
+        progress: {
+            completed: number;
+            total: number;
+        };
+        worker: any;
+        activeRequests: {};
+        classificationPlanFiles: any[];
+        onCompleteCallback: any;
+        pendingNodes: any[];
+        displayContext: any;
+        requalifyResolvedCounter: number;
+    } & PiniaCustomStateProperties<{
+        isUploading: boolean;
+        files: any[];
+        progress: {
+            completed: number;
+            total: number;
+        };
+        worker: any;
+        activeRequests: {};
+        classificationPlanFiles: any[];
+        onCompleteCallback: any;
+        pendingNodes: any[];
+        displayContext: any;
+        requalifyResolvedCounter: number;
+    }>): any;
+    overallMessage(state: {
+        isUploading: boolean;
+        files: any[];
+        progress: {
+            completed: number;
+            total: number;
+        };
+        worker: any;
+        activeRequests: {};
+        classificationPlanFiles: any[];
+        onCompleteCallback: any;
+        pendingNodes: any[];
+        displayContext: any;
+        requalifyResolvedCounter: number;
+    } & PiniaCustomStateProperties<{
+        isUploading: boolean;
+        files: any[];
+        progress: {
+            completed: number;
+            total: number;
+        };
+        worker: any;
+        activeRequests: {};
+        classificationPlanFiles: any[];
+        onCompleteCallback: any;
+        pendingNodes: any[];
+        displayContext: any;
+        requalifyResolvedCounter: number;
+    }>): string;
+}, {
+    startUpload(uploadItems: any, nodeId: any): void;
+    initializeWorker(): void;
+    onWorkerMessage({ type, payload }: {
+        type: any;
+        payload: any;
+    }): Promise<void>;
+    handleUploadRequest(item: any, nodeId: any): Promise<void>;
+    cancelUpload(fileName: any): void;
+    clearCompleted(): void;
+    /**
+     * Declares what the current page lists and how it reruns its query.
+     *
+     * @param {?{siteId?: string, activeViewId?: string, activeViewConfig?: Object, parentNodeId?: string, listingSource?: ("db"|"search"), refresh?: Function}} context
+     *   `listingSource` missing or unknown means `search`; `refresh` is required for a page to wait for the index
+     */
+    setDisplayContext(context: {
+        siteId?: string;
+        activeViewId?: string;
+        activeViewConfig?: any;
+        parentNodeId?: string;
+        listingSource?: ("db" | "search");
+        refresh?: Function;
+    } | null): void;
+    /**
+     * Former name of `setDisplayContext`, kept for existing callers.
+     *
+     * @param {?Object} context
+     */
+    setGhostContext(context: any | null): void;
+    addGhostNode(ghostData: any): void;
+    removeGhostNode(nodeId: any): void;
+    /**
+     * Update a pre-created ghost with real data after upload success.
+     * Finds the ghost by _originalFileName (stored at creation time).
+     */
+    updateGhostAfterUpload(fileName: any, data: any): void;
+    /**
+     * Remove a pre-created ghost on upload failure.
+     */
+    removeGhostByTempKey(fileName: any): void;
+    /**
+     * Waits until nodes are searchable for the current page, then reruns its
+     * query. The applications call it after their own actions.
+     *
+     * @param {string[]} nodeIds
+     * @param {{onUnavailable?: Function, onRefresh?: Function, listingSource?: ("db"|"search"), refreshOnDone?: boolean, timeout?: number, background?: boolean}} [options]
+     *   `listingSource` and `onRefresh` default to the display context's `listingSource` and `refresh`
+     * @returns {Promise<{status: string, searchable: string[], errors: Array<Object>, rejected: string[], pending: string[]}>}
+     */
+    awaitIndexed(nodeIds: string[], options?: {
+        onUnavailable?: Function;
+        onRefresh?: Function;
+        listingSource?: ("db" | "search");
+        refreshOnDone?: boolean;
+        timeout?: number;
+        background?: boolean;
+    }): Promise<{
+        status: string;
+        searchable: string[];
+        errors: Array<any>;
+        rejected: string[];
+        pending: string[];
+    }>;
+    notifyUploadBusy(): void;
+    resolveUploadMode(context?: any): Promise<"ghost" | "await">;
+    beginUploadBatch(ghosts: any, inheritContext: any): void;
+    addGhosts(ghosts: any, inheritContext: any, context?: any): void;
+    recordUploadSuccess(fileName: any, data: any): Promise<void>;
+    recordUploadFailure(fileName: any): Promise<void>;
+    finishUploadBatch(): Promise<void>;
+    startRequalifyPolling(): void;
+    stopRequalifyPolling(): void;
+    cleanExpiredGhosts(ttl?: number): void;
+    /**
+     * Start upload with classification plan
+     * Uses the injector webscript to upload files with metadata
+     * @param {string} workspaceSiteId - Site ID of the workspace
+     * @param {string} pathFull - Full path within the site
+     * @param {Array} files - Array of File objects to upload
+     * @param {Object} metadata - Metadata properties to inject
+     * @param {Array} fileRenames - Array of {original, new} rename mappings
+     */
+    startUploadWithClassificationPlan(workspaceSiteId: string, pathFull: string, files: any[], metadata: any, fileRenames: any[], destinationNodeId: any): void;
+    /**
+     * Start a classification plan upload where each file has its own
+     * pathFull, metadata, and fileRenames.
+     * @param {string} workspaceSiteId
+     * @param {File[]} files
+     * @param {Object[]} perFileData - Array of { pathFull, metadata, fileRenames } per file
+     * @param {string} destinationNodeId
+     */
+    startUploadWithClassificationPlanMulti(workspaceSiteId: string, files: File[], perFileData: any[], destinationNodeId: string): void;
+    /**
+     * Handle classification plan upload request from worker
+     * Uses multipart/form-data for efficient upload without base64 encoding
+     */
+    handleClassificationPlanUpload(item: any): Promise<void>;
+}>;
+//# sourceMappingURL=upload.d.ts.map

package/dist/stores/upload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/stores/upload.js"],"names":[],"mappings":";AAsDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAsQI;;;;;OAKG;+BAFS;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,MAAS;QAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,CAAC,IAAI,GAAC,QAAQ,CAAC,CAAC;QAAC,OAAO,CAAC,WAAU;KAAC,OAAA;IAO3J;;;;OAIG;6BADQ,UAAO;;;IA+BlB;;;OAGG;;IAUH;;OAEG;;IAUH;;;;;;;;OAQG;0BAJQ,MAAM,EAAE,YACR;QAAC,aAAa,CAAC,WAAW;QAAC,SAAS,CAAC,WAAW;QAAC,aAAa,CAAC,EAAE,CAAC,IAAI,GAAC,QAAQ,CAAC,CAAC;QAAC,aAAa,CAAC,EAAE,OAAO,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,OAAO,CAAA;KAAC,GAEhJ,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,EAAE,CAAC;QAAC,MAAM,EAAE,KAAK,KAAQ,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,OAAO,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC;;;;;;;;;;;IAmL1H;;;;;;;;OAQG;uDALQ,MAAM,YACN,MAAM;IAwFjB;;;;;;;OAOG;4DAJQ,MAAM,SACN,IAAI,EAAE,eACN,KAAQ,qBACR,MAAM;IAkFjB;;;OAGG;;GA6IJ"}