@lancercomet/zoom-pan 0.1.0

package/dist/zoom-pan.d.ts

@@ -0,0 +1,831 @@
+export declare type AnchorType = 'topLeft' | 'center';
+
+/**
+ * Image is used to load and display an image in world space.
+ */
+export declare class BitmapLayer extends CanvasLayer {
+    #private;
+    /** 从图片源创建位图层（会把像素绘入离屏） */
+    static fromImage(options: ICreateBitmapLayerOptions): Promise<BitmapLayer>;
+    /** 替换图源（尺寸会重配） */
+    setSource(src: string | File | Blob, crossOrigin?: '' | 'anonymous' | 'use-credentials'): Promise<void>;
+    /** 在位图上作画（提供 ctx） */
+    paint(fn: (ctx: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void): void;
+    /** 读取/写回像素 */
+    getImageData(sx?: number, sy?: number, sw?: number, sh?: number): ImageData;
+    putImageData(img: ImageData, dx?: number, dy?: number): void;
+    /** 导出（PNG dataURL 或 ImageBitmap） */
+    toDataURL(type?: string, quality?: number): string;
+    toImageBitmap(opts?: ImageBitmapOptions): Promise<ImageBitmap>;
+    destroy(): void;
+    private constructor();
+}
+
+export declare type BlendMode = GlobalCompositeOperation;
+
+/**
+ * CanvasLayer is used to create a layer with an offscreen canvas in either world or screen space.
+ * You can draw anything you want on the offscreen canvas, and it will be rendered as a layer.
+ */
+export declare class CanvasLayer extends LayerBase {
+    private readonly _redraw?;
+    readonly canvas: HTMLCanvasElement;
+    readonly context: CanvasRenderingContext2D;
+    x: number;
+    y: number;
+    scale: number;
+    rotation: number;
+    anchor: AnchorType;
+    private _drawing;
+    private _lastX;
+    private _lastY;
+    /**
+     * Begin a stroke at the given world coordinates.
+     */
+    beginStroke(wx: number, wy: number): void;
+    /**
+     * Continue a stroke to the given world coordinates.
+     */
+    stroke(wx: number, wy: number, color: string, size: number, pressure?: number, mode?: 'brush' | 'eraser'): void;
+    /**
+     * End the current stroke.
+     */
+    endStroke(): void;
+    /**
+     * Check if currently drawing.
+     */
+    isDrawing(): boolean;
+    /**
+     * Capture a snapshot of the canvas content.
+     * If region is provided, only that region is captured (more memory efficient).
+     * Returns null if capture fails.
+     */
+    captureSnapshot(region?: IRect): ImageData | null;
+    /**
+     * Restore a snapshot to the canvas.
+     * If position is provided, the snapshot is placed at that position.
+     * Otherwise, it's placed at (0, 0).
+     */
+    restoreSnapshot(data: ImageData, position?: {
+        x: number;
+        y: number;
+    }): void;
+    /**
+     * Clear a region of the canvas.
+     * If no region is provided, clears the entire canvas.
+     */
+    clearRegion(region?: IRect): void;
+    /**
+     * Request a redraw of the offscreen canvas.
+     * This will call the redraw function you provided in the constructor.
+     */
+    requestRedraw(): void;
+    /**
+     * Draw an image onto the offscreen canvas.
+     */
+    drawImage(image: HTMLImageElement | HTMLCanvasElement | ImageBitmap, dx: number, dy: number, dw?: number, dh?: number): void;
+    /**
+     * Hit test the layer.
+     * Returns true if the point (wx, wy) in world space is within the layer bounds.
+     */
+    hitTest(wx: number, wy: number): boolean;
+    /**
+     * Convert a point from world space to local layer space.
+     */
+    toLocalPoint(wx: number, wy: number): {
+        lx: number;
+        ly: number;
+    };
+    /**
+     * Render the layer onto the given context.
+     */
+    render(ctx: CanvasRenderingContext2D, view?: ViewManager): void;
+    cropTo(config: ILayerResizeConfig): void;
+    resizeTo(config: ILayerResizeConfig): void;
+    private _cloneCanvas;
+    private _setCanvasSize;
+    destroy(): void;
+    constructor(options: ICreateCanvasLayerOption);
+}
+
+export declare type CommandType = 'snapshot' | string;
+
+/**
+ * Content Layer Manager is used to store content bitmaps.
+ * Uses a composite cache to avoid re-rendering all layers every frame.
+ */
+export declare class ContentLayerManager extends LayerManagerBase {
+    private _compositeCache;
+    private _compositeCacheCtx;
+    private _compositeDirty;
+    private _lastCacheWidth;
+    private _lastCacheHeight;
+    private _cachedBoundsMinX;
+    private _cachedBoundsMinY;
+    /**
+     * Mark the composite cache as dirty.
+     * Call this when any layer content changes.
+     */
+    markDirty(): void;
+    /**
+     * Override addLayer to mark cache dirty.
+     */
+    addLayer(layer: LayerBase, insertAt?: number): string;
+    /**
+     * Override removeLayer to mark cache dirty.
+     */
+    removeLayer(id: string): void;
+    /**
+     * Override moveLayer to mark cache dirty.
+     */
+    moveLayer(id: string, toIndex: number): void;
+    /**
+     * Render all layers in target view.
+     * Uses composite cache for better performance with many layers.
+     */
+    renderAllLayersIn(view: ViewManager): void;
+    /**
+     * Rebuild the composite cache from all world layers.
+     */
+    private _rebuildCompositeCache;
+    /**
+     * Override destroy to clean up cache.
+     */
+    destroy(): void;
+}
+
+/**
+ * Create a document plugin instance.
+ */
+export declare function createDocumentPlugin(options?: DocumentPluginOptions): DocumentPlugin;
+
+/**
+ * Create an interaction plugin instance.
+ */
+export declare function createInteractionPlugin(options?: InteractionPluginOptions): InteractionPlugin;
+
+/**
+ * Helper function to create a snapshot command.
+ *
+ * Usage:
+ * ```typescript
+ * // Before starting the action
+ * const before = layer.captureSnapshot()
+ *
+ * // ... perform some drawing ...
+ *
+ * // After the action is complete
+ * const after = layer.captureSnapshot()
+ * const command = createSnapshotCommand(layer, before, after)
+ * historyManager.addCommand(command)
+ * ```
+ */
+export declare function createSnapshotCommand(target: ISnapshotable, beforeData: ImageData | null, afterData: ImageData | null, options?: SnapshotCommandOptions): SnapshotCommand | null;
+
+/**
+ * Document Plugin
+ *
+ * Manages document bounds, margins, clipping, and pan clamping.
+ */
+export declare class DocumentPlugin implements Plugin_2 {
+    readonly name = "document";
+    private _view;
+    private _options;
+    private _enabled;
+    private _x;
+    private _y;
+    private _width;
+    private _height;
+    private _marginL;
+    private _marginR;
+    private _marginT;
+    private _marginB;
+    private _panClampMode;
+    constructor(options?: DocumentPluginOptions);
+    install(view: ViewManager): void;
+    destroy(): void;
+    isEnabled(): boolean;
+    getRect(): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    setRect(x: number, y: number, width: number, height: number): void;
+    clearRect(): void;
+    setMargins(margins: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    }): void;
+    getMargins(): {
+        left: number;
+        right: number;
+        top: number;
+        bottom: number;
+    };
+    setPanClampMode(mode: PanClampMode): void;
+    getPanClampMode(): PanClampMode;
+    /**
+     * Crop document and all world layers to the specified size.
+     */
+    cropTo(config: ILayerResizeConfig): void;
+    /**
+     * Resize document and all world layers to the specified size.
+     */
+    resizeTo(config: ILayerResizeConfig): void;
+    /**
+     * Zoom to fit the document in the viewport.
+     */
+    zoomToFit(mode?: 'contain' | 'cover' | 'fitWidth' | 'fitHeight'): void;
+    /**
+     * Check if a world point is inside the document.
+     */
+    isPointInDocument(wx: number, wy: number): boolean;
+    private _onUpdate;
+    private _onBeforeRender;
+    private _onAfterRender;
+    private _clampPan;
+    private _doResize;
+}
+
+export declare interface DocumentPluginOptions {
+    /**
+     * Initial document rectangle (world coordinates).
+     */
+    rect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Initial margins (CSS pixels).
+     */
+    margins?: {
+        left?: number;
+        right?: number;
+        top?: number;
+        bottom?: number;
+    };
+    /**
+     * Draw 1px border around document. Default false.
+     */
+    drawBorder?: boolean;
+    /**
+     * The min visible edge of the document in px when clamping pan. Default 30.
+     */
+    minVisiblePx?: number;
+    /**
+     * Pan clamp mode. Default 'minVisible'.
+     */
+    panClampMode?: PanClampMode;
+}
+
+/**
+ * 历史管理器：管理撤销/重做操作的命令栈
+ */
+export declare class HistoryManager {
+    private _maxHistorySize;
+    private _undoStack;
+    private _redoStack;
+    /**
+     * 执行命令并记录到历史
+     * 用于需要执行+记录的场景（如从外部触发的命令）
+     */
+    executeCommand(command: ICommand): void;
+    /**
+     * 将已执行的命令添加到历史记录
+     * 用于实时绘制场景（命令已经通过其他方式执行完成）
+     */
+    addCommand(command: ICommand): void;
+    /**
+     * 撤销操作
+     */
+    undo(): ICommand | null;
+    /**
+     * 重做操作
+     */
+    redo(): ICommand | null;
+    /**
+     * 检查是否可以撤销
+     */
+    canUndo(): boolean;
+    /**
+     * 检查是否可以重做
+     */
+    canRedo(): boolean;
+    /**
+     * 清空所有历史
+     */
+    clear(): void;
+    /**
+     * 设置最大历史大小
+     */
+    setMaxHistorySize(size: number): void;
+    constructor(options?: {
+        /**
+         * Maximum number of commands to keep in history.
+         *
+         * @default 50
+         */
+        maxHistorySize?: number;
+        /**
+         * You can optionally provide initial undo and redo stacks.
+         * This is useful in some situations like loading from a saved state,
+         * or already having a Vue reactive array to use.
+         *
+         * @default []
+         */
+        undoStack?: ICommand[];
+        /**
+         * You can optionally provide initial undo and redo stacks.
+         * This is useful in some situations like loading from a saved state,
+         * or already having a Vue reactive array to use.
+         *
+         * @default []
+         */
+        redoStack?: ICommand[];
+    });
+}
+
+export declare interface ICommand {
+    readonly type: CommandType;
+    execute(): void;
+    undo(): void;
+    canMerge?(other: ICommand): boolean;
+    merge?(other: ICommand): ICommand;
+}
+
+export declare interface ICreateBitmapLayerOptions {
+    src: string | File | Blob;
+    width?: number;
+    height?: number;
+    name?: string;
+    x?: number;
+    y?: number;
+    scale?: number;
+    rotation?: number;
+    anchor?: AnchorType;
+    space?: SpaceType;
+    crossOrigin?: '' | 'anonymous' | 'use-credentials';
+}
+
+export declare interface ICreateCanvasLayerOption {
+    name?: string;
+    width: number;
+    height: number;
+    /**
+     * The space of the layer, either 'world' or 'screen'.
+     *
+     * @default 'world'
+     */
+    space?: SpaceType;
+    x?: number;
+    y?: number;
+    scale?: number;
+    rotation?: number;
+    anchor?: AnchorType;
+    redraw?: (context: CanvasRenderingContext2D, canvas: HTMLCanvasElement) => void;
+}
+
+export declare interface ILayerResizeConfig {
+    width: number;
+    height: number;
+}
+
+/**
+ * Interaction Plugin
+ *
+ * Handles pan (drag), zoom (wheel), and inertia.
+ * Can be enabled/disabled at runtime.
+ */
+export declare class InteractionPlugin implements Plugin_2 {
+    readonly name = "interaction";
+    private _view;
+    private _options;
+    private _panEnabled;
+    private _zoomEnabled;
+    private _dragging;
+    private _vx;
+    private _vy;
+    private _lastMoveTs;
+    private _activePointerId;
+    private _onDownBound;
+    private _onMoveBound;
+    private _onUpBound;
+    private _onWheelBound;
+    constructor(options?: InteractionPluginOptions);
+    install(view: ViewManager): void;
+    destroy(): void;
+    isPanEnabled(): boolean;
+    isZoomEnabled(): boolean;
+    setPanEnabled(enabled: boolean): void;
+    setZoomEnabled(enabled: boolean): void;
+    setWheelSensitivity(s: number): void;
+    isDragging(): boolean;
+    private _onUpdate;
+    private _onPointerDown;
+    private _onPointerMove;
+    private _onPointerUp;
+    private _getLineHeightPx;
+    private _normalizeWheelDelta;
+    private _onWheel;
+}
+
+export declare interface InteractionPluginOptions {
+    /**
+     * Enable pan (drag to move). Default true.
+     */
+    panEnabled?: boolean;
+    /**
+     * Enable zoom (wheel to scale). Default true.
+     */
+    zoomEnabled?: boolean;
+    /**
+     * Friction for inertia (per frame). Default 0.92.
+     */
+    friction?: number;
+    /**
+     * Stop speed threshold (px/ms). Default 20/1000.
+     */
+    stopSpeed?: number;
+    /**
+     * EMA alpha for velocity smoothing. Default 0.25.
+     */
+    emaAlpha?: number;
+    /**
+     * Idle time (ms) before clearing inertia on pointer up. Default 120.
+     */
+    idleNoInertiaMs?: number;
+    /**
+     * Wheel sensitivity (pixel -> log step multiplier). Default 0.0015.
+     */
+    wheelSensitivity?: number;
+}
+
+export declare interface IRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+/**
+ * Interface for objects that can capture and restore snapshots.
+ * CanvasLayer implements this interface.
+ */
+export declare interface ISnapshotable {
+    captureSnapshot(region?: ISnapshotRegion): ImageData | null;
+    restoreSnapshot(data: ImageData, position?: {
+        x: number;
+        y: number;
+    }): void;
+}
+
+export declare interface ISnapshotRegion {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+
+export declare abstract class LayerBase {
+    readonly id: string;
+    type: string;
+    name: string;
+    space: SpaceType;
+    visible: boolean;
+    opacity: number;
+    blend: BlendMode;
+    abstract render(context: CanvasRenderingContext2D, view?: ViewManager): void;
+    abstract destroy(): void;
+    abstract hitTest(x: number, y: number, view?: ViewManager): boolean;
+    protected constructor(name: string, type: string, space?: SpaceType);
+}
+
+export declare class LayerManagerBase {
+    protected _worldLayers: LayerBase[];
+    protected _screenLayers: LayerBase[];
+    /**
+     * Render all layers in target view.
+     */
+    protected _renderAllLayersIn(view: ViewManager, context: CanvasRenderingContext2D): void;
+    addLayer(layer: LayerBase, insertAt?: number): string;
+    createImageLayer(option: ICreateBitmapLayerOptions): Promise<BitmapLayer>;
+    createCanvasLayer(option: ICreateCanvasLayerOption): CanvasLayer;
+    removeLayer(id: string): void;
+    /**
+     * Move a layer from one index to another.
+     * Both indices are relative to the layer's space (world or screen).
+     */
+    moveLayer(id: string, toIndex: number): void;
+    getLayer(id: string): LayerBase | undefined;
+    getAllLayers(space?: SpaceType): LayerBase[];
+    /**
+     * Hit test all layers (top-first).
+     *
+     * @param x
+     * @param y
+     * @param space
+     */
+    hitTest(x: number, y: number, space?: 'world' | 'screen'): LayerBase | undefined;
+    destroy(): void;
+}
+
+export declare type PanClampMode = 'margin' | 'minVisible';
+
+/**
+ * Plugin interface for ViewManager.
+ * Plugins can extend the core functionality with additional features.
+ */
+declare interface Plugin_2 {
+    /**
+     * Unique name of the plugin.
+     */
+    readonly name: string;
+    /**
+     * Called when the plugin is installed on a ViewManager instance.
+     * @param view The ViewManager instance
+     */
+    install(view: ViewManager): void;
+    /**
+     * Called when the plugin is uninstalled or the ViewManager is destroyed.
+     */
+    destroy(): void;
+}
+export { Plugin_2 as Plugin }
+
+/**
+ * Plugin constructor type for creating plugin instances.
+ */
+export declare type PluginConstructor<T extends Plugin_2 = Plugin_2, O = unknown> = new (options?: O) => T;
+
+/**
+ * Plugin factory function type.
+ */
+export declare type PluginFactory<T extends Plugin_2 = Plugin_2, O = unknown> = (options?: O) => T;
+
+export declare type RenderCallback = (ctx: CanvasRenderingContext2D) => void;
+
+export declare type RenderFn = (view: ViewManager) => void;
+
+/**
+ * A generic command that stores before/after snapshots for undo/redo.
+ * This command is decoupled from any specific layer implementation.
+ */
+export declare class SnapshotCommand implements ICommand {
+    readonly type = "snapshot";
+    private readonly _target;
+    private readonly _beforeData;
+    private readonly _afterData;
+    private readonly _region?;
+    private _isExecuted;
+    /**
+     * Create a snapshot command.
+     *
+     * @param target - The object to restore snapshots to (must implement ISnapshotable)
+     * @param beforeData - The snapshot before the change
+     * @param afterData - The snapshot after the change
+     * @param options - Optional configuration
+     */
+    constructor(target: ISnapshotable, beforeData: ImageData, afterData: ImageData, options?: SnapshotCommandOptions);
+    execute(): void;
+    undo(): void;
+    canMerge(): boolean;
+    merge(): ICommand;
+}
+
+export declare interface SnapshotCommandOptions {
+    /**
+     * The region of the snapshot. If not provided, uses full canvas.
+     */
+    region?: ISnapshotRegion;
+}
+
+export declare type SpaceType = 'world' | 'screen';
+
+/**
+ * Top Screen Layer Manager is used to store top screen overlays.
+ * If you have something like UI elements, just put it here.
+ */
+export declare class TopScreenLayerManager extends LayerManagerBase {
+    /**
+     * Render all layers in target view.
+     */
+    renderAllLayersIn(view: ViewManager): void;
+}
+
+export declare type UpdateCallback = (dt: number) => void;
+
+export declare class ViewManager {
+    readonly canvas: HTMLCanvasElement;
+    readonly context: CanvasRenderingContext2D;
+    readonly contentCanvas: HTMLCanvasElement;
+    readonly contentContext: CanvasRenderingContext2D;
+    readonly topScreenCanvas: HTMLCanvasElement;
+    readonly topScreenContext: CanvasRenderingContext2D;
+    private readonly _render;
+    private readonly _options;
+    private readonly _resizeObserver?;
+    private _layerManagers;
+    private _plugins;
+    private _isResetting;
+    private _isResizing;
+    private _resizeReleaseTimer;
+    private _needsRender;
+    private _raf;
+    private _lastFrameTs;
+    private _tx;
+    private _ty;
+    private _anchorX;
+    private _anchorY;
+    private _currentLogZ;
+    private _targetLogZ;
+    private LOG_MIN;
+    private LOG_MAX;
+    private _updateCallbacks;
+    private _beforeRenderCallbacks;
+    private _afterRenderCallbacks;
+    get zoom(): number;
+    get minZoom(): number;
+    get maxZoom(): number;
+    private _dpr;
+    get dpr(): number;
+    /**
+     * Install a plugin.
+     */
+    use<T extends Plugin_2>(plugin: T): T;
+    /**
+     * Uninstall a plugin by name.
+     */
+    unuse(name: string): void;
+    /**
+     * Get an installed plugin by name.
+     */
+    getPlugin<T extends Plugin_2>(name: string): T | undefined;
+    /**
+     * Register a callback to be called every frame with delta time.
+     */
+    onUpdate(callback: UpdateCallback): void;
+    /**
+     * Unregister an update callback.
+     */
+    offUpdate(callback: UpdateCallback): void;
+    /**
+     * Register a callback to be called before rendering (with world transform applied).
+     */
+    onBeforeRender(callback: RenderCallback): void;
+    /**
+     * Unregister a before-render callback.
+     */
+    offBeforeRender(callback: RenderCallback): void;
+    /**
+     * Register a callback to be called after rendering.
+     */
+    onAfterRender(callback: RenderCallback): void;
+    /**
+     * Unregister an after-render callback.
+     */
+    offAfterRender(callback: RenderCallback): void;
+    /**
+     * Request a render on the next frame.
+     * Call this when content changes and needs to be redrawn.
+     */
+    requestRender(): void;
+    /**
+     * Clamp target zoom (log space) to range.
+     */
+    private _clampLog;
+    /**
+     * Set target zoom at screen anchor point, with smooth transition.
+     */
+    private _setTargetLogZoomAtScreen;
+    /**
+     * Zoom to absolute zoom level at screen point, with smooth transition.
+     */
+    zoomToAtScreen(anchorX: number, anchorY: number, zoom: number): void;
+    /**
+     * Zoom to absolute zoom level at screen point, instantly (no animation).
+     */
+    zoomToAtScreenRaw(anchorX: number, anchorY: number, zoom: number): void;
+    /**
+     * Zoom to absolute zoom level at world point, with smooth transition.
+     */
+    zoomToAtWorld(wx: number, wy: number, zoom: number): void;
+    /**
+     * Zoom by multiplicative factor at screen point, with smooth transition.
+     */
+    zoomByFactorAtScreen(anchorX: number, anchorY: number, factor: number): void;
+    /**
+     * Zoom by log step at screen point. Used by interaction plugin.
+     */
+    zoomByLogAtScreen(anchorX: number, anchorY: number, stepLog: number): void;
+    /**
+     * Zoom by multiplicative factor at world point, with smooth transition.
+     */
+    zoomByFactorAtWorld(wx: number, wy: number, factor: number): void;
+    zoomInAtCenter(): void;
+    zoomOutAtCenter(): void;
+    /**
+     * Pan by delta (CSS px).
+     */
+    panBy(dx: number, dy: number): void;
+    /**
+     * Set pan position (CSS px).
+     */
+    setPan(tx: number, ty: number): void;
+    /**
+     * Set full transform: zoom and pan.
+     */
+    setTransform(zoom: number, tx: number, ty: number): void;
+    private _ensureOffscreenSizeLike;
+    private _loop;
+    applyWorldTransform(ctx: CanvasRenderingContext2D): void;
+    applyScreenTransform(ctx: CanvasRenderingContext2D): void;
+    getPixelColorAtScreen(sx: number, sy: number): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        rgba: string;
+        hex: string;
+    };
+    getPixelColorAtWorld(wx: number, wy: number): {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        rgba: string;
+        hex: string;
+    };
+    registerLayerManager(manager: LayerManagerBase): void;
+    unregisterLayerManager(manager: LayerManagerBase): void;
+    getLayerManagers(): LayerManagerBase[];
+    /**
+     * Smoothly reset to zoom=1, pan=(0,0).
+     */
+    resetSmooth(): void;
+    /**
+     * Instantly reset (no animation).
+     */
+    resetInstant(): void;
+    /**
+     * Convert screen (canvas client) -> world.
+     */
+    toWorld(x: number, y: number): {
+        wx: number;
+        wy: number;
+    };
+    /**
+     * Convert world -> screen (canvas client).
+     */
+    toScreen(wx: number, wy: number): {
+        x: number;
+        y: number;
+    };
+    /**
+     * Get current transform.
+     */
+    getTransform(): {
+        zoom: number;
+        tx: number;
+        ty: number;
+    };
+    /**
+     * Get viewport bounds in world coordinates.
+     */
+    getViewportBounds(): {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+        width: number;
+        height: number;
+    };
+    /**
+     * Set zoom range.
+     */
+    setZoomRange(minZoom: number, maxZoom: number): void;
+    /**
+     * Resize canvas to match parent size and DPR.
+     */
+    resizeToParent(): void;
+    /**
+     * Destroy and cleanup.
+     */
+    destroy(): void;
+    constructor(canvas: HTMLCanvasElement, render: RenderFn, options?: ViewManagerOption);
+}
+
+export declare interface ViewManagerOption {
+    minZoom?: number;
+    maxZoom?: number;
+    approachKZoom?: number;
+    approachKPan?: number;
+    autoResize?: boolean;
+    background?: string | null;
+}
+
+export { }