@cornerstonejs/tools 3.0.2 → 3.0.4

package/dist/esm/stateManagement/annotation/AnnotationRenderingEngine.d.ts

@@ -0,0 +1,20 @@
+declare class AnnotationRenderingEngine {
+    hasBeenDestroyed: boolean;
+    private _needsRender;
+    private _animationFrameSet;
+    private _animationFrameHandle;
+    private _viewportElements;
+    constructor();
+    addViewportElement(viewportId: string, element: HTMLDivElement): void;
+    removeViewportElement(viewportId: string, element: HTMLDivElement): void;
+    renderViewport(element: HTMLDivElement): void;
+    private _throwIfDestroyed;
+    private _renderFlaggedViewports;
+    private _setAllViewportsToBeRenderedNextFrame;
+    private _setViewportsToBeRenderedNextFrame;
+    private _render;
+    _triggerRender(element: any): void;
+    private _reset;
+}
+declare const annotationRenderingEngine: AnnotationRenderingEngine;
+export { annotationRenderingEngine };

package/dist/esm/stateManagement/annotation/AnnotationRenderingEngine.js

@@ -0,0 +1,112 @@
+import { getEnabledElement, triggerEvent, getRenderingEngine, } from '@cornerstonejs/core';
+import { Events, ToolModes } from '../../enums';
+import { draw as drawSvg } from '../../drawingSvg';
+import getToolsWithModesForElement from '../../utilities/getToolsWithModesForElement';
+const { Active, Passive, Enabled } = ToolModes;
+class AnnotationRenderingEngine {
+    constructor() {
+        this._needsRender = new Set();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._renderFlaggedViewports = () => {
+            this._throwIfDestroyed();
+            const elements = Array.from(this._viewportElements.values());
+            for (let i = 0; i < elements.length; i++) {
+                const element = elements[i];
+                if (this._needsRender.has(element)) {
+                    this._triggerRender(element);
+                    this._needsRender.delete(element);
+                    if (this._needsRender.size === 0) {
+                        break;
+                    }
+                }
+            }
+            this._animationFrameSet = false;
+            this._animationFrameHandle = null;
+            this._render();
+        };
+        this._viewportElements = new Map();
+    }
+    addViewportElement(viewportId, element) {
+        this._viewportElements.set(viewportId, element);
+    }
+    removeViewportElement(viewportId, element) {
+        this._viewportElements.delete(viewportId);
+        this._needsRender.delete(element);
+        this._reset();
+    }
+    renderViewport(element) {
+        this._setViewportsToBeRenderedNextFrame([element]);
+    }
+    _throwIfDestroyed() {
+        if (this.hasBeenDestroyed) {
+            throw new Error('this.destroy() has been manually called to free up memory, can not longer use this instance. Instead make a new one.');
+        }
+    }
+    _setAllViewportsToBeRenderedNextFrame() {
+        const elements = [...this._viewportElements.values()];
+        elements.forEach((element) => {
+            this._needsRender.add(element);
+        });
+        this._renderFlaggedViewports();
+    }
+    _setViewportsToBeRenderedNextFrame(elements) {
+        const elementsEnabled = [...this._viewportElements.values()];
+        elements.forEach((element) => {
+            if (elementsEnabled.indexOf(element) !== -1) {
+                this._needsRender.add(element);
+            }
+        });
+        this._render();
+    }
+    _render() {
+        if (this._needsRender.size > 0 && this._animationFrameSet === false) {
+            this._animationFrameHandle = window.requestAnimationFrame(this._renderFlaggedViewports);
+            this._animationFrameSet = true;
+        }
+    }
+    _triggerRender(element) {
+        const enabledElement = getEnabledElement(element);
+        if (!enabledElement) {
+            return;
+        }
+        const renderingEngine = getRenderingEngine(enabledElement.renderingEngineId);
+        if (!renderingEngine) {
+            console.warn('rendering Engine has been destroyed');
+            return;
+        }
+        const enabledTools = getToolsWithModesForElement(element, [
+            Active,
+            Passive,
+            Enabled,
+        ]);
+        const { renderingEngineId, viewportId } = enabledElement;
+        const eventDetail = {
+            element,
+            renderingEngineId,
+            viewportId,
+        };
+        drawSvg(element, (svgDrawingHelper) => {
+            let anyRendered = false;
+            const handleDrawSvg = (tool) => {
+                if (tool.renderAnnotation) {
+                    const rendered = tool.renderAnnotation(enabledElement, svgDrawingHelper);
+                    anyRendered = anyRendered || rendered;
+                }
+            };
+            enabledTools.forEach(handleDrawSvg);
+            if (anyRendered) {
+                triggerEvent(element, Events.ANNOTATION_RENDERED, { ...eventDetail });
+            }
+        });
+    }
+    _reset() {
+        window.cancelAnimationFrame(this._animationFrameHandle);
+        this._needsRender.clear();
+        this._animationFrameSet = false;
+        this._animationFrameHandle = null;
+        this._setAllViewportsToBeRenderedNextFrame();
+    }
+}
+const annotationRenderingEngine = new AnnotationRenderingEngine();
+export { annotationRenderingEngine };

package/dist/esm/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.d.ts

@@ -0,0 +1,27 @@
+import type { Annotation, Annotations, AnnotationState, GroupSpecificAnnotations } from '../../types/AnnotationTypes';
+import type { AnnotationGroupSelector, IAnnotationManager } from '../../types';
+import type { Types } from '@cornerstonejs/core';
+declare class FrameOfReferenceSpecificAnnotationManager implements IAnnotationManager {
+    private annotations;
+    readonly uid: string;
+    private preprocessingFn;
+    constructor(uid?: string);
+    getGroupKey: (annotationGroupSelector: AnnotationGroupSelector) => string;
+    _imageVolumeModifiedHandler: (evt: Types.EventTypes.ImageVolumeModifiedEvent) => void;
+    getFramesOfReference: () => Array<string>;
+    getAnnotations: (groupKey: string, toolName?: string) => GroupSpecificAnnotations | Annotations;
+    getAnnotation: (annotationUID: string) => Annotation | undefined;
+    getNumberOfAnnotations: (groupKey: string, toolName?: string) => number;
+    addAnnotation: (annotation: Annotation, groupKey?: string) => void;
+    removeAnnotation: (annotationUID: string) => void;
+    removeAnnotations: (groupKey: string, toolName?: string) => Annotations;
+    saveAnnotations: (groupKey?: string, toolName?: string) => AnnotationState | GroupSpecificAnnotations | Annotations;
+    restoreAnnotations: (state: AnnotationState | GroupSpecificAnnotations | Annotations, groupKey?: string, toolName?: string) => void;
+    getAllAnnotations: () => Annotations;
+    getNumberOfAllAnnotations: () => number;
+    removeAllAnnotations: () => Annotations;
+    setPreprocessingFn(preprocessingFn: (annotation: Annotation) => Annotation): void;
+}
+declare const defaultFrameOfReferenceSpecificAnnotationManager: FrameOfReferenceSpecificAnnotationManager;
+export { defaultFrameOfReferenceSpecificAnnotationManager };
+export default FrameOfReferenceSpecificAnnotationManager;

package/dist/esm/stateManagement/annotation/FrameOfReferenceSpecificAnnotationManager.js

@@ -0,0 +1,210 @@
+import { Enums, eventTarget, getEnabledElement, utilities, } from '@cornerstonejs/core';
+class FrameOfReferenceSpecificAnnotationManager {
+    constructor(uid) {
+        this.getGroupKey = (annotationGroupSelector) => {
+            if (typeof annotationGroupSelector === 'string') {
+                return annotationGroupSelector;
+            }
+            const element = annotationGroupSelector;
+            const enabledElement = getEnabledElement(element);
+            if (!enabledElement) {
+                throw new Error('Element not enabled, you must have an enabled element if you are not providing a FrameOfReferenceUID');
+            }
+            return enabledElement.FrameOfReferenceUID;
+        };
+        this._imageVolumeModifiedHandler = (evt) => {
+            const eventDetail = evt.detail;
+            const { FrameOfReferenceUID } = eventDetail;
+            const annotations = this.annotations;
+            const frameOfReferenceSpecificAnnotations = annotations[FrameOfReferenceUID];
+            if (!frameOfReferenceSpecificAnnotations) {
+                return;
+            }
+            Object.keys(frameOfReferenceSpecificAnnotations).forEach((toolName) => {
+                const toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
+                toolSpecificAnnotations.forEach((annotation) => {
+                    const invalidated = annotation.invalidated;
+                    if (invalidated !== undefined) {
+                        annotation.invalidated = true;
+                    }
+                });
+            });
+        };
+        this.getFramesOfReference = () => {
+            return Object.keys(this.annotations);
+        };
+        this.getAnnotations = (groupKey, toolName) => {
+            const annotations = this.annotations;
+            if (!annotations[groupKey]) {
+                return [];
+            }
+            if (toolName) {
+                return annotations[groupKey][toolName]
+                    ? annotations[groupKey][toolName]
+                    : [];
+            }
+            return annotations[groupKey];
+        };
+        this.getAnnotation = (annotationUID) => {
+            const annotations = this.annotations;
+            for (const frameOfReferenceUID in annotations) {
+                const frameOfReferenceAnnotations = annotations[frameOfReferenceUID];
+                for (const toolName in frameOfReferenceAnnotations) {
+                    const toolSpecificAnnotations = frameOfReferenceAnnotations[toolName];
+                    for (const annotation of toolSpecificAnnotations) {
+                        if (annotationUID === annotation.annotationUID) {
+                            return annotation;
+                        }
+                    }
+                }
+            }
+        };
+        this.getNumberOfAnnotations = (groupKey, toolName) => {
+            const annotations = this.getAnnotations(groupKey, toolName);
+            if (!annotations.length) {
+                return 0;
+            }
+            if (toolName) {
+                return annotations.length;
+            }
+            let total = 0;
+            for (const toolName in annotations) {
+                total += annotations[toolName].length;
+            }
+            return total;
+        };
+        this.addAnnotation = (annotation, groupKey) => {
+            const { metadata } = annotation;
+            const { FrameOfReferenceUID, toolName } = metadata;
+            groupKey = groupKey || FrameOfReferenceUID;
+            const annotations = this.annotations;
+            let frameOfReferenceSpecificAnnotations = annotations[groupKey];
+            if (!frameOfReferenceSpecificAnnotations) {
+                annotations[groupKey] = {};
+                frameOfReferenceSpecificAnnotations = annotations[groupKey];
+            }
+            let toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
+            if (!toolSpecificAnnotations) {
+                frameOfReferenceSpecificAnnotations[toolName] = [];
+                toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
+            }
+            if (this.preprocessingFn) {
+                annotation = this.preprocessingFn(annotation);
+            }
+            toolSpecificAnnotations.push(annotation);
+        };
+        this.removeAnnotation = (annotationUID) => {
+            const { annotations } = this;
+            for (const groupKey in annotations) {
+                const groupAnnotations = annotations[groupKey];
+                for (const toolName in groupAnnotations) {
+                    const toolAnnotations = groupAnnotations[toolName];
+                    const index = toolAnnotations.findIndex((annotation) => annotation.annotationUID === annotationUID);
+                    if (index !== -1) {
+                        toolAnnotations.splice(index, 1);
+                        if (toolAnnotations.length === 0) {
+                            delete groupAnnotations[toolName];
+                        }
+                    }
+                }
+                if (Object.keys(groupAnnotations).length === 0) {
+                    delete annotations[groupKey];
+                }
+            }
+        };
+        this.removeAnnotations = (groupKey, toolName) => {
+            const annotations = this.annotations;
+            const removedAnnotations = [];
+            if (!annotations[groupKey]) {
+                return removedAnnotations;
+            }
+            if (toolName) {
+                const annotationsForTool = annotations[groupKey][toolName];
+                for (const annotation of annotationsForTool) {
+                    this.removeAnnotation(annotation.annotationUID);
+                    removedAnnotations.push(annotation);
+                }
+            }
+            else {
+                for (const toolName in annotations[groupKey]) {
+                    const annotationsForTool = annotations[groupKey][toolName];
+                    for (const annotation of annotationsForTool) {
+                        this.removeAnnotation(annotation.annotationUID);
+                        removedAnnotations.push(annotation);
+                    }
+                }
+            }
+            return removedAnnotations;
+        };
+        this.saveAnnotations = (groupKey, toolName) => {
+            const annotations = this.annotations;
+            if (groupKey && toolName) {
+                const frameOfReferenceSpecificAnnotations = annotations[groupKey];
+                if (!frameOfReferenceSpecificAnnotations) {
+                    return;
+                }
+                const toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
+                return structuredClone(toolSpecificAnnotations);
+            }
+            else if (groupKey) {
+                const frameOfReferenceSpecificAnnotations = annotations[groupKey];
+                return structuredClone(frameOfReferenceSpecificAnnotations);
+            }
+            return structuredClone(annotations);
+        };
+        this.restoreAnnotations = (state, groupKey, toolName) => {
+            const annotations = this.annotations;
+            if (groupKey && toolName) {
+                let frameOfReferenceSpecificAnnotations = annotations[groupKey];
+                if (!frameOfReferenceSpecificAnnotations) {
+                    annotations[groupKey] = {};
+                    frameOfReferenceSpecificAnnotations = annotations[groupKey];
+                }
+                frameOfReferenceSpecificAnnotations[toolName] = state;
+            }
+            else if (groupKey) {
+                annotations[groupKey] = state;
+            }
+            else {
+                this.annotations = structuredClone(state);
+            }
+        };
+        this.getAllAnnotations = () => {
+            return Object.values(this.annotations)
+                .map((frameOfReferenceSpecificAnnotations) => Object.values(frameOfReferenceSpecificAnnotations))
+                .flat(2);
+        };
+        this.getNumberOfAllAnnotations = () => {
+            let count = 0;
+            const annotations = this.annotations;
+            for (const groupKey in annotations) {
+                const frameOfReferenceSpecificAnnotations = annotations[groupKey];
+                for (const toolName in frameOfReferenceSpecificAnnotations) {
+                    const toolSpecificAnnotations = frameOfReferenceSpecificAnnotations[toolName];
+                    count += toolSpecificAnnotations.length;
+                }
+            }
+            return count;
+        };
+        this.removeAllAnnotations = () => {
+            const removedAnnotations = [];
+            for (const annotation of this.getAllAnnotations()) {
+                this.removeAnnotation(annotation.annotationUID);
+                removedAnnotations.push(annotation);
+            }
+            return removedAnnotations;
+        };
+        if (!uid) {
+            uid = utilities.uuidv4();
+        }
+        this.annotations = {};
+        this.uid = uid;
+        eventTarget.addEventListener(Enums.Events.IMAGE_VOLUME_MODIFIED, this._imageVolumeModifiedHandler);
+    }
+    setPreprocessingFn(preprocessingFn) {
+        this.preprocessingFn = preprocessingFn;
+    }
+}
+const defaultFrameOfReferenceSpecificAnnotationManager = new FrameOfReferenceSpecificAnnotationManager('DEFAULT');
+export { defaultFrameOfReferenceSpecificAnnotationManager };
+export default FrameOfReferenceSpecificAnnotationManager;

package/dist/esm/stateManagement/annotation/annotationLocking.d.ts

@@ -0,0 +1,7 @@
+declare function setAnnotationLocked(annotationUID: string, locked?: boolean): void;
+declare function unlockAllAnnotations(): void;
+declare function getAnnotationsLocked(): Array<string>;
+declare function isAnnotationLocked(annotationUID: string): boolean;
+declare function getAnnotationsLockedCount(): number;
+declare function checkAndSetAnnotationLocked(annotationUID: string): boolean;
+export { setAnnotationLocked, getAnnotationsLocked, getAnnotationsLockedCount, unlockAllAnnotations, isAnnotationLocked, checkAndSetAnnotationLocked, };

package/dist/esm/stateManagement/annotation/annotationLocking.js

@@ -0,0 +1,73 @@
+import { eventTarget, triggerEvent } from '@cornerstonejs/core';
+import { Events } from '../../enums';
+import { getAnnotation } from './annotationState';
+const globalLockedAnnotationUIDsSet = new Set();
+function setAnnotationLocked(annotationUID, locked = true) {
+    const detail = makeEventDetail();
+    if (annotationUID) {
+        if (locked) {
+            lock(annotationUID, globalLockedAnnotationUIDsSet, detail);
+        }
+        else {
+            unlock(annotationUID, globalLockedAnnotationUIDsSet, detail);
+        }
+    }
+    publish(detail, globalLockedAnnotationUIDsSet);
+}
+function unlockAllAnnotations() {
+    const detail = makeEventDetail();
+    clearLockedAnnotationsSet(globalLockedAnnotationUIDsSet, detail);
+    publish(detail, globalLockedAnnotationUIDsSet);
+}
+function getAnnotationsLocked() {
+    return Array.from(globalLockedAnnotationUIDsSet);
+}
+function isAnnotationLocked(annotationUID) {
+    return globalLockedAnnotationUIDsSet.has(annotationUID);
+}
+function getAnnotationsLockedCount() {
+    return globalLockedAnnotationUIDsSet.size;
+}
+function checkAndSetAnnotationLocked(annotationUID) {
+    const isLocked = isAnnotationLocked(annotationUID);
+    setAnnotationLocked(annotationUID, isLocked);
+    return isLocked;
+}
+function makeEventDetail() {
+    return Object.freeze({
+        added: [],
+        removed: [],
+        locked: [],
+    });
+}
+function lock(annotationUID, lockedAnnotationUIDsSet, detail) {
+    if (!lockedAnnotationUIDsSet.has(annotationUID)) {
+        lockedAnnotationUIDsSet.add(annotationUID);
+        detail.added.push(annotationUID);
+        const annotation = getAnnotation(annotationUID);
+        if (annotation) {
+            annotation.isLocked = true;
+        }
+    }
+}
+function unlock(annotationUID, lockedAnnotationUIDsSet, detail) {
+    if (lockedAnnotationUIDsSet.delete(annotationUID)) {
+        detail.removed.push(annotationUID);
+        const annotation = getAnnotation(annotationUID);
+        if (annotation) {
+            annotation.isLocked = false;
+        }
+    }
+}
+function clearLockedAnnotationsSet(lockedAnnotationUIDsSet, detail) {
+    lockedAnnotationUIDsSet.forEach((annotationUID) => {
+        unlock(annotationUID, lockedAnnotationUIDsSet, detail);
+    });
+}
+function publish(detail, lockedAnnotationUIDsSet) {
+    if (detail.added.length > 0 || detail.removed.length > 0) {
+        lockedAnnotationUIDsSet.forEach((item) => void detail.locked.push(item));
+        triggerEvent(eventTarget, Events.ANNOTATION_LOCK_CHANGE, detail);
+    }
+}
+export { setAnnotationLocked, getAnnotationsLocked, getAnnotationsLockedCount, unlockAllAnnotations, isAnnotationLocked, checkAndSetAnnotationLocked, };

package/dist/esm/stateManagement/annotation/annotationSelection.d.ts

@@ -0,0 +1,7 @@
+declare function setAnnotationSelected(annotationUID: string, selected?: boolean, preserveSelected?: boolean): void;
+declare function deselectAnnotation(annotationUID?: string): void;
+declare function getAnnotationsSelected(): Array<string>;
+declare function getAnnotationsSelectedByToolName(toolName: string): Array<string>;
+declare function isAnnotationSelected(annotationUID: string): boolean;
+declare function getAnnotationsSelectedCount(): number;
+export { setAnnotationSelected, getAnnotationsSelected, getAnnotationsSelectedByToolName, getAnnotationsSelectedCount, deselectAnnotation, isAnnotationSelected, };

package/dist/esm/stateManagement/annotation/annotationSelection.js

@@ -0,0 +1,85 @@
+import { eventTarget, triggerEvent } from '@cornerstonejs/core';
+import { Events } from '../../enums';
+import { getAnnotation } from './annotationState';
+const selectedAnnotationUIDs = new Set();
+function setAnnotationSelected(annotationUID, selected = true, preserveSelected = false) {
+    if (selected) {
+        selectAnnotation(annotationUID, preserveSelected);
+    }
+    else {
+        deselectAnnotation(annotationUID);
+    }
+}
+function selectAnnotation(annotationUID, preserveSelected = false) {
+    const detail = makeEventDetail();
+    if (!preserveSelected) {
+        clearSelectionSet(selectedAnnotationUIDs, detail);
+        const annotation = getAnnotation(annotationUID);
+        if (annotation) {
+            annotation.isSelected = true;
+        }
+    }
+    if (annotationUID && !selectedAnnotationUIDs.has(annotationUID)) {
+        selectedAnnotationUIDs.add(annotationUID);
+        detail.added.push(annotationUID);
+        const annotation = getAnnotation(annotationUID);
+        if (annotation) {
+            annotation.isSelected = true;
+        }
+    }
+    publish(detail, selectedAnnotationUIDs);
+}
+function deselectAnnotation(annotationUID) {
+    const detail = makeEventDetail();
+    if (annotationUID) {
+        if (selectedAnnotationUIDs.delete(annotationUID)) {
+            detail.removed.push(annotationUID);
+            const annotation = getAnnotation(annotationUID);
+            annotation.isSelected = false;
+        }
+    }
+    else {
+        clearSelectionSet(selectedAnnotationUIDs, detail);
+    }
+    publish(detail, selectedAnnotationUIDs);
+}
+function getAnnotationsSelected() {
+    return Array.from(selectedAnnotationUIDs);
+}
+function getAnnotationsSelectedByToolName(toolName) {
+    return getAnnotationsSelected().filter((annotationUID) => {
+        const annotation = getAnnotation(annotationUID);
+        return annotation?.metadata?.toolName === toolName;
+    });
+}
+function isAnnotationSelected(annotationUID) {
+    return selectedAnnotationUIDs.has(annotationUID);
+}
+function getAnnotationsSelectedCount() {
+    return selectedAnnotationUIDs.size;
+}
+function makeEventDetail() {
+    return Object.freeze({
+        added: [],
+        removed: [],
+        selection: [],
+    });
+}
+function clearSelectionSet(selectionSet, detail) {
+    selectionSet.forEach((value) => {
+        if (selectionSet.delete(value)) {
+            detail.removed.push(value);
+            const annotation = getAnnotation(value);
+            if (annotation) {
+                annotation.isSelected = false;
+            }
+        }
+    });
+}
+function publish(detail, selectionSet) {
+    if (detail.added.length > 0 || detail.removed.length > 0) {
+        selectionSet.forEach((item) => void detail.selection.push(item));
+        triggerEvent(eventTarget, Events.ANNOTATION_SELECTION_CHANGE, detail);
+    }
+}
+export { setAnnotationSelected, getAnnotationsSelected, getAnnotationsSelectedByToolName, getAnnotationsSelectedCount, deselectAnnotation, isAnnotationSelected, };

package/dist/esm/stateManagement/annotation/annotationState.d.ts

@@ -0,0 +1,18 @@
+import type { Annotations, Annotation } from '../../types/AnnotationTypes';
+import type { AnnotationGroupSelector, IAnnotationManager } from '../../types';
+declare function getAnnotationManager(): any;
+declare function setAnnotationManager(annotationManager: IAnnotationManager): void;
+declare function getAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): Annotations;
+declare function getAnnotation(annotationUID: string): Annotation;
+declare function getAllAnnotations(): Annotations;
+declare function clearParentAnnotation(annotation: Annotation): void;
+declare function addChildAnnotation(parentAnnotation: Annotation, childAnnotation: Annotation): void;
+declare function getParentAnnotation(annotation: Annotation): Annotation;
+declare function getChildAnnotations(annotation: Annotation): Annotation[];
+declare function addAnnotation(annotation: Annotation, annotationGroupSelector: AnnotationGroupSelector): string;
+declare function getNumberOfAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): number;
+declare function removeAnnotation(annotationUID: string): void;
+declare function removeAllAnnotations(): void;
+declare function removeAnnotations(toolName: string, annotationGroupSelector: AnnotationGroupSelector): void;
+declare function invalidateAnnotation(annotation: Annotation): void;
+export { getAllAnnotations, getAnnotations, getParentAnnotation, getChildAnnotations, clearParentAnnotation, addChildAnnotation, getNumberOfAnnotations, addAnnotation, removeAnnotation, removeAnnotations, removeAllAnnotations, setAnnotationManager, getAnnotationManager, invalidateAnnotation, getAnnotation, };