@insync-stageplayer/annotations 0.5.32 → 0.5.35-beta.1

package/lib/components/AnnotationsModuleProvider.js

@@ -1,21 +1,21 @@
-import React, { useMemo } from "react";
-import { annotationsAdapter } from "../redux/annotations.slice";
-import { measurementDisplaysAdapter } from "../redux/measurementDisplays.slice";
-export const AnnotationsModuleContext = React.createContext({});
-/**
- * Provides the functionalities in this module to its children components.
- *
- * @param props
- * @returns
- */
-export const AnnotationsModuleProvider = (props) => {
-    const { selector, children } = props;
-    const entitiesSelectors = useMemo(() => {
-        return {
-            annotations: annotationsAdapter.getSelectors((s) => selector(s).annotations),
-            measurementDisplays: measurementDisplaysAdapter.getSelectors((s) => selector(s).measurementDisplays),
-        };
-    }, [selector]);
-    return (React.createElement(AnnotationsModuleContext.Provider, { value: { selector, entitiesSelectors } }, children));
-};
+import React, { useMemo } from "react";
+import { annotationsAdapter } from "../redux/annotations.slice";
+import { measurementDisplaysAdapter } from "../redux/measurementDisplays.slice";
+export const AnnotationsModuleContext = React.createContext({});
+/**
+ * Provides the functionalities in this module to its children components.
+ *
+ * @param props
+ * @returns
+ */
+export const AnnotationsModuleProvider = (props) => {
+    const { selector, children } = props;
+    const entitiesSelectors = useMemo(() => {
+        return {
+            annotations: annotationsAdapter.getSelectors((s) => selector(s).annotations),
+            measurementDisplays: measurementDisplaysAdapter.getSelectors((s) => selector(s).measurementDisplays),
+        };
+    }, [selector]);
+    return (React.createElement(AnnotationsModuleContext.Provider, { value: { selector, entitiesSelectors } }, children));
+};
 //# sourceMappingURL=AnnotationsModuleProvider.js.map

package/lib/components/AnnotationsViewer.d.ts

@@ -1,16 +1,16 @@
-import React from "react";
-declare type AnnotationsViewerProps = React.HTMLAttributes<HTMLDivElement> & {
-    /**
-     * The annotations to be displayed inside this AnnotationsViewer.
-     */
-    annotations: string[];
-};
-/**
- * Given a list of annotation ids, will render them.
- *
- * @param param0
- * @returns
- */
-export declare const AnnotationsViewer: React.FC<AnnotationsViewerProps>;
-export {};
+import React from "react";
+declare type AnnotationsViewerProps = React.HTMLAttributes<HTMLDivElement> & {
+    /**
+     * The annotations to be displayed inside this AnnotationsViewer.
+     */
+    annotations: string[];
+};
+/**
+ * Given a list of annotation ids, will render them.
+ *
+ * @param param0
+ * @returns
+ */
+export declare const AnnotationsViewer: React.FC<AnnotationsViewerProps>;
+export {};
 //# sourceMappingURL=AnnotationsViewer.d.ts.map

package/lib/components/AnnotationsViewer.js

@@ -1,110 +1,110 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import React, { useContext, useCallback, useMemo } from "react";
-import { shallowEqual, useDispatch, useSelector } from "react-redux";
-import { styled } from "@insync-stageplayer/ui-components";
-import { AnnotationContent, } from "./AnnotationContent";
-import { DraggablePosition } from "./DraggablePosition";
-import { editAnnotation, updateAnnotation } from "../redux/annotations.slice";
-import { AnnotationsModuleContext } from "./AnnotationsModuleProvider";
-import MeasurementDisplayElement from "./MeasurementDisplayElement";
-import { useBoundingRect } from "../useBoundingRect";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import React, { useContext, useCallback, useMemo } from "react";
+import { shallowEqual, useDispatch, useSelector } from "react-redux";
+import { styled } from "@insync-stageplayer/ui-components";
+import { AnnotationContent, } from "./AnnotationContent";
+import { DraggablePosition } from "./DraggablePosition";
+import { editAnnotation, updateAnnotation } from "../redux/annotations.slice";
+import { AnnotationsModuleContext } from "./AnnotationsModuleProvider";
+import MeasurementDisplayElement from "./MeasurementDisplayElement";
+import { useBoundingRect } from "../useBoundingRect";
 const StyledAnnotationContent = styled(AnnotationContent) `
   cursor: pointer;
-`;
-/**
- * Wrapper around MeasurementDisplayElement to make it compatible with slate.js
- * @param props
- * @returns
- */
-const MeasurementDisplayElementRenderer = ({ element, attributes, children, }) => {
-    const { measurementDisplayId } = element;
-    return (React.createElement("span", Object.assign({}, attributes),
-        React.createElement(MeasurementDisplayElement, { id: measurementDisplayId, editable: false, xRange: { start: 0, duration: 50000 } }),
-        children));
-};
-/**
- * The additions to slate-js for rendering custom elements.
- */
-const contentElements = {
-    measurementDisplay: {
-        isVoid: true,
-        inline: true,
-        renderer: MeasurementDisplayElementRenderer,
-    },
-};
-/**
- * Given a list of annotation ids, will render them.
- *
- * @param param0
- * @returns
- */
-export const AnnotationsViewer = (_a) => {
-    var { annotations } = _a, rest = __rest(_a, ["annotations"]);
-    const [boundsRef, bounds] = useBoundingRect();
-    /**
-     * Consume the AnnotationsModule context so that we have access to the annotations slice
-     * in the redux state.
-     */
-    const { entitiesSelectors } = useContext(AnnotationsModuleContext);
-    const dispatch = useDispatch();
-    /**
-     * Selects the annotations for the given ids from the redux state, will
-     * do a shallowEqual comparison to prevent rerenders if an annotation is changed
-     * that is not displayed in this AnnotationViewer.
-     */
-    const dirtyEntities = useSelector((s) => {
-        return entitiesSelectors.annotations
-            .selectAll(s)
-            .filter((v) => annotations.indexOf(v.id) !== -1);
-    }, shallowEqual);
-    const entities = useMemo(() => {
-        return dirtyEntities.map((annotation) => {
-            var _a;
-            const go = (node) => {
-                if ((node.type === "measurementDisplay" || node.type === "paragraph") &&
-                    !node.children) {
-                    return Object.assign(Object.assign({}, node), { children: [
-                            {
-                                text: "",
-                            },
-                        ] });
-                }
-                if (Array.isArray(node.children)) {
-                    return Object.assign(Object.assign({}, node), { children: node.children.map(go) });
-                    // return node.children.map(go);
-                }
-                return node;
-            };
-            // Transforming the Annotation to a SlateJS node.
-            return Object.assign(Object.assign({}, annotation), { content: (_a = annotation.content) === null || _a === void 0 ? void 0 : _a.map(go) });
-        });
-    }, [dirtyEntities]);
-    /**
-     * Dispatches an action to redux and updates the position of an annotation.
-     */
-    const handleMoveAnnotation = useCallback((id) => (ev, position) => {
-        dispatch(updateAnnotation({
-            id,
-            changes: {
-                position,
-            },
-        }));
-    }, [dispatch]);
-    return (React.createElement(React.Fragment, null,
-        React.createElement("div", Object.assign({}, rest, { ref: boundsRef }), bounds &&
-            entities.map((e) => (React.createElement(DraggablePosition, { key: e.id, position: e.position, bounds: bounds, onMoveEnd: handleMoveAnnotation(e.id) },
-                React.createElement(StyledAnnotationContent, { content: e.content, onClick: () => {
-                        dispatch(editAnnotation(e.id));
-                    }, elements: contentElements })))))));
-};
+`;
+/**
+ * Wrapper around MeasurementDisplayElement to make it compatible with slate.js
+ * @param props
+ * @returns
+ */
+const MeasurementDisplayElementRenderer = ({ element, attributes, children, }) => {
+    const { measurementDisplayId } = element;
+    return (React.createElement("span", Object.assign({}, attributes),
+        React.createElement(MeasurementDisplayElement, { id: measurementDisplayId, editable: false, xRange: { start: 0, duration: 50000 } }),
+        children));
+};
+/**
+ * The additions to slate-js for rendering custom elements.
+ */
+const contentElements = {
+    measurementDisplay: {
+        isVoid: true,
+        inline: true,
+        renderer: MeasurementDisplayElementRenderer,
+    },
+};
+/**
+ * Given a list of annotation ids, will render them.
+ *
+ * @param param0
+ * @returns
+ */
+export const AnnotationsViewer = (_a) => {
+    var { annotations } = _a, rest = __rest(_a, ["annotations"]);
+    const [boundsRef, bounds] = useBoundingRect();
+    /**
+     * Consume the AnnotationsModule context so that we have access to the annotations slice
+     * in the redux state.
+     */
+    const { entitiesSelectors } = useContext(AnnotationsModuleContext);
+    const dispatch = useDispatch();
+    /**
+     * Selects the annotations for the given ids from the redux state, will
+     * do a shallowEqual comparison to prevent rerenders if an annotation is changed
+     * that is not displayed in this AnnotationViewer.
+     */
+    const dirtyEntities = useSelector((s) => {
+        return entitiesSelectors.annotations
+            .selectAll(s)
+            .filter((v) => annotations.indexOf(v.id) !== -1);
+    }, shallowEqual);
+    const entities = useMemo(() => {
+        return dirtyEntities.map((annotation) => {
+            var _a;
+            const go = (node) => {
+                if ((node.type === "measurementDisplay" || node.type === "paragraph") &&
+                    !node.children) {
+                    return Object.assign(Object.assign({}, node), { children: [
+                            {
+                                text: "",
+                            },
+                        ] });
+                }
+                if (Array.isArray(node.children)) {
+                    return Object.assign(Object.assign({}, node), { children: node.children.map(go) });
+                    // return node.children.map(go);
+                }
+                return node;
+            };
+            // Transforming the Annotation to a SlateJS node.
+            return Object.assign(Object.assign({}, annotation), { content: (_a = annotation.content) === null || _a === void 0 ? void 0 : _a.map(go) });
+        });
+    }, [dirtyEntities]);
+    /**
+     * Dispatches an action to redux and updates the position of an annotation.
+     */
+    const handleMoveAnnotation = useCallback((id) => (ev, position) => {
+        dispatch(updateAnnotation({
+            id,
+            changes: {
+                position,
+            },
+        }));
+    }, [dispatch]);
+    return (React.createElement(React.Fragment, null,
+        React.createElement("div", Object.assign({}, rest, { ref: boundsRef }), bounds &&
+            entities.map((e) => (React.createElement(DraggablePosition, { key: e.id, position: e.position, bounds: bounds, onMoveEnd: handleMoveAnnotation(e.id) },
+                React.createElement(StyledAnnotationContent, { content: e.content, onClick: () => {
+                        dispatch(editAnnotation(e.id));
+                    }, elements: contentElements })))))));
+};
 //# sourceMappingURL=AnnotationsViewer.js.map

package/lib/components/DraggablePosition.d.ts

@@ -1,32 +1,32 @@
-import { Position2D } from "@insync-stageplayer/common";
-import { MoveEvent } from "react-move-hook";
-import React from "react";
-interface AnnotationPositionProps extends React.HTMLAttributes<HTMLDivElement> {
-    /**
-     * The xy position of the annotation represented in a decimal value between 0 and 1
-     */
-    position: Position2D;
-    /**
-     * The bounds within the annotations are displayed in pixels
-     */
-    bounds: DOMRect;
-    /**
-     * Callback when moving starts
-     */
-    onMoveStart?: (ev: MoveEvent, position: Position2D) => void;
-    /**
-     * Callback when moving ends
-     */
-    onMoveEnd?: (ev: MoveEvent, position: Position2D) => void;
-    /**
-     * Callback when moving
-     */
-    onMove?: (ev: MoveEvent, position: Position2D) => void;
-}
-/**
- * A position with drag & drop functionality
- * @param props
- */
-export declare const DraggablePosition: React.FC<AnnotationPositionProps>;
-export {};
+import { Position2D } from "@insync-stageplayer/common";
+import { MoveEvent } from "react-move-hook";
+import React from "react";
+interface AnnotationPositionProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * The xy position of the annotation represented in a decimal value between 0 and 1
+     */
+    position: Position2D;
+    /**
+     * The bounds within the annotations are displayed in pixels
+     */
+    bounds: DOMRect;
+    /**
+     * Callback when moving starts
+     */
+    onMoveStart?: (ev: MoveEvent, position: Position2D) => void;
+    /**
+     * Callback when moving ends
+     */
+    onMoveEnd?: (ev: MoveEvent, position: Position2D) => void;
+    /**
+     * Callback when moving
+     */
+    onMove?: (ev: MoveEvent, position: Position2D) => void;
+}
+/**
+ * A position with drag & drop functionality
+ * @param props
+ */
+export declare const DraggablePosition: React.FC<AnnotationPositionProps>;
+export {};
 //# sourceMappingURL=DraggablePosition.d.ts.map

package/lib/components/DraggablePosition.js

@@ -1,23 +1,23 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { styled } from "@insync-stageplayer/ui-components";
-import { useMovable } from "react-move-hook";
-import React, { useCallback, useRef, useState } from "react";
-const calcRelativePosition = (ev, origin, bounds) => {
-    return {
-        x: origin.x + ev.delta.x / bounds.width,
-        y: origin.y + ev.delta.y / bounds.height,
-    };
-};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { styled } from "@insync-stageplayer/ui-components";
+import { useMovable } from "react-move-hook";
+import React, { useCallback, useRef, useState } from "react";
+const calcRelativePosition = (ev, origin, bounds) => {
+    return {
+        x: origin.x + ev.delta.x / bounds.width,
+        y: origin.y + ev.delta.y / bounds.height,
+    };
+};
 const Handle = styled.div `
   position: absolute;
   border-radius: 100%;
@@ -26,9 +26,9 @@ const Handle = styled.div `
   top: 0.25em;
   left: 0.25em;
   cursor: move;
-`;
-const Component = styled.div.attrs({
-    className: "p-3",
+`;
+const Component = styled.div.attrs({
+    className: "p-3",
 }) `
   border: 2px solid transparent;
   :hover {
@@ -37,43 +37,43 @@ const Component = styled.div.attrs({
       background-color: ${(props) => { var _a; return ((_a = props.theme.colors) === null || _a === void 0 ? void 0 : _a.secondary) || "black"; }};
     }
   }
-`;
-/**
- * A position with drag & drop functionality
- * @param props
- */
-export const DraggablePosition = (_a) => {
-    var { position, bounds, style: styleProp, className, onMoveStart, onMoveEnd, onMove, children } = _a, rest = __rest(_a, ["position", "bounds", "style", "className", "onMoveStart", "onMoveEnd", "onMove", "children"]);
-    // The current drag position, this will takes preference over the position prop.
-    const [move, setMove] = useState();
-    const sizeRef = useRef(null);
-    const handleMove = useCallback((ev) => {
-        setMove(ev);
-        if (onMove)
-            onMove(ev, calcRelativePosition(ev, position, bounds));
-    }, [onMove, bounds, position]);
-    const handleMoveStart = useCallback(() => {
-        (ev) => {
-            setMove(ev);
-            if (onMoveStart)
-                onMoveStart(ev, calcRelativePosition(ev, position, bounds));
-        };
-    }, [bounds, onMoveStart, position]);
-    const handleMoveEnd = useCallback((ev) => {
-        setMove(undefined);
-        if (onMoveEnd)
-            onMoveEnd(ev, calcRelativePosition(ev, position, bounds));
-    }, [bounds, onMoveEnd, position]);
-    // Using the useMovable hook to handle drag & drop functionality.
-    const ref = useMovable(Object.assign(Object.assign({}, (bounds ? { bounds } : { unbounded: true })), { onMoveStart: handleMoveStart, onMoveEnd: handleMoveEnd, onMove: handleMove, sizeRef }));
-    // The CSS styles we will attach to the output HTML node
-    const style = Object.assign(Object.assign({}, styleProp), { position: "absolute", left: position.x * bounds.width, top: position.y * bounds.height });
-    if (move && move.moving) {
-        style.transform = `translate3d(${move.delta.x}px, ${move.delta.y}px, 0)`;
-        style.userSelect = "none";
-    }
-    return (React.createElement(Component, Object.assign({ ref: sizeRef }, rest, { style: style }),
-        React.createElement(Handle, { ref: ref }),
-        children));
-};
+`;
+/**
+ * A position with drag & drop functionality
+ * @param props
+ */
+export const DraggablePosition = (_a) => {
+    var { position, bounds, style: styleProp, className, onMoveStart, onMoveEnd, onMove, children } = _a, rest = __rest(_a, ["position", "bounds", "style", "className", "onMoveStart", "onMoveEnd", "onMove", "children"]);
+    // The current drag position, this will takes preference over the position prop.
+    const [move, setMove] = useState();
+    const sizeRef = useRef(null);
+    const handleMove = useCallback((ev) => {
+        setMove(ev);
+        if (onMove)
+            onMove(ev, calcRelativePosition(ev, position, bounds));
+    }, [onMove, bounds, position]);
+    const handleMoveStart = useCallback(() => {
+        (ev) => {
+            setMove(ev);
+            if (onMoveStart)
+                onMoveStart(ev, calcRelativePosition(ev, position, bounds));
+        };
+    }, [bounds, onMoveStart, position]);
+    const handleMoveEnd = useCallback((ev) => {
+        setMove(undefined);
+        if (onMoveEnd)
+            onMoveEnd(ev, calcRelativePosition(ev, position, bounds));
+    }, [bounds, onMoveEnd, position]);
+    // Using the useMovable hook to handle drag & drop functionality.
+    const ref = useMovable(Object.assign(Object.assign({}, (bounds ? { bounds } : { unbounded: true })), { onMoveStart: handleMoveStart, onMoveEnd: handleMoveEnd, onMove: handleMove, sizeRef }));
+    // The CSS styles we will attach to the output HTML node
+    const style = Object.assign(Object.assign({}, styleProp), { position: "absolute", left: position.x * bounds.width, top: position.y * bounds.height });
+    if (move && move.moving) {
+        style.transform = `translate3d(${move.delta.x}px, ${move.delta.y}px, 0)`;
+        style.userSelect = "none";
+    }
+    return (React.createElement(Component, Object.assign({ ref: sizeRef }, rest, { style: style }),
+        React.createElement(Handle, { ref: ref }),
+        children));
+};
 //# sourceMappingURL=DraggablePosition.js.map

package/lib/components/MeasurementDisplayDataContext.d.ts

@@ -1,11 +1,11 @@
-/// <reference types="react" />
-import { MeasurementsTypes } from "@insync-stageplayer/measurements";
-declare type MeasurementDisplayDataValue = {
-    register: (id: MeasurementsTypes.Measurement) => () => void;
-    loading: boolean;
-    error?: Error;
-    data?: MeasurementsTypes.DataMap;
-};
-export declare const MeasurementDisplayDataContext: import("react").Context<MeasurementDisplayDataValue>;
-export {};
+/// <reference types="react" />
+import { MeasurementsTypes } from "@insync-stageplayer/measurements";
+declare type MeasurementDisplayDataValue = {
+    register: (id: MeasurementsTypes.Measurement) => () => void;
+    loading: boolean;
+    error?: Error;
+    data?: MeasurementsTypes.DataMap;
+};
+export declare const MeasurementDisplayDataContext: import("react").Context<MeasurementDisplayDataValue>;
+export {};
 //# sourceMappingURL=MeasurementDisplayDataContext.d.ts.map

package/lib/components/MeasurementDisplayDataContext.js

@@ -1,3 +1,3 @@
-import { createContext } from "react";
-export const MeasurementDisplayDataContext = createContext({});
+import { createContext } from "react";
+export const MeasurementDisplayDataContext = createContext({});
 //# sourceMappingURL=MeasurementDisplayDataContext.js.map

package/lib/components/MeasurementDisplayDataProvider.d.ts

@@ -1,16 +1,16 @@
-import { Timer } from "@insync-stageplayer/time";
-import React from "react";
-declare type MeasurementDisplayDataProviderProps = {
-    /**
-     * A Timer (from @insync-stageplayer/time) that emits times.
-     */
-    timer: Timer;
-};
-/**
- * Provides data for measurement displays. Keeps track of all registered measurement displays inside annotations.
- * @param props
- * @returns
- */
-export declare const MeasurementDisplayDataProvider: React.FC<MeasurementDisplayDataProviderProps>;
-export {};
+import { Timer } from "@insync-stageplayer/time";
+import React from "react";
+declare type MeasurementDisplayDataProviderProps = {
+    /**
+     * A Timer (from @insync-stageplayer/time) that emits times.
+     */
+    timer: Timer;
+};
+/**
+ * Provides data for measurement displays. Keeps track of all registered measurement displays inside annotations.
+ * @param props
+ * @returns
+ */
+export declare const MeasurementDisplayDataProvider: React.FC<MeasurementDisplayDataProviderProps>;
+export {};
 //# sourceMappingURL=MeasurementDisplayDataProvider.d.ts.map

package/lib/components/MeasurementDisplayDataProvider.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeasurementDisplayDataProvider.d.ts","sourceRoot":"","sources":["../../src/components/MeasurementDisplayDataProvider.tsx"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjD,OAAO,KAAyC,MAAM,OAAO,CAAC;AAI9D,aAAK,mCAAmC,GAAG;IACzC;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,EAAE,KAAK,CAAC,EAAE,CAAC,mCAAmC,CAuDtF,CAAC"}
+{"version":3,"file":"MeasurementDisplayDataProvider.d.ts","sourceRoot":"","sources":["../../src/components/MeasurementDisplayDataProvider.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AACjD,OAAO,KAAyC,MAAM,OAAO,CAAC;AAI9D,aAAK,mCAAmC,GAAG;IACzC;;OAEG;IACH,KAAK,EAAE,KAAK,CAAC;CACd,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,EAAE,KAAK,CAAC,EAAE,CAAC,mCAAmC,CAuDtF,CAAC"}