@univerjs/sheets-drawing-ui 0.2.4 → 0.2.6

package/lib/es/index.js

@@ -1,2172 +1,2154 @@
-var en = Object.defineProperty;
-var tn = (i, e, n) => e in i ? en(i, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : i[e] = n;
-var H = (i, e, n) => tn(i, typeof e != "symbol" ? e + "" : e, n);
-import { CommandType as F, ICommandService as V, IUndoRedoService as ge, LocaleService as _e, IUniverInstanceService as he, RxDisposable as nn, UniverInstanceType as B, toDisposable as rn, FOCUSING_COMMON_DRAWINGS as we, OnLifecycle as ie, LifecycleStages as se, IContextService as _t, Disposable as oe, Direction as q, FOCUSING_FORMULA_EDITOR as sn, EDITOR_ACTIVATED as on, Rectangle as an, DrawingTypeEnum as Ye, DisposableCollection as cn, Tools as ne, UserManagerService as dn, IPermissionService as ln, Plugin as un, DependentOn as gn } from "@univerjs/core";
-import { Inject as W, Injector as nt } from "@wendellhu/redi";
-import { ImageCropperObject as hn, COMPONENT_IMAGE_POPUP_MENU as mn, OpenImageCropOperation as fn, ImageResetSizeOperation as pn, DrawingCommonPanel as wn, DrawingRenderService as _n, UniverDrawingUIPlugin as vn } from "@univerjs/drawing-ui";
-import { ISheetDrawingService as k, SetDrawingApplyMutation as E, DrawingApplyType as y, SheetDrawingAnchorType as O, UniverSheetsDrawingPlugin as Sn } from "@univerjs/sheets-drawing";
-import { IDrawingManagerService as z, IImageIoService as vt, ArrangeTypeEnum as Ce, DrawingTypeEnum as Ve, DRAWING_IMAGE_COUNT_LIMIT as dt, ImageUploadStatusType as ke, DRAWING_IMAGE_ALLOW_SIZE as Cn, getImageSize as In, DRAWING_IMAGE_WIDTH_LIMIT as lt, DRAWING_IMAGE_HEIGHT_LIMIT as ut, DRAWING_IMAGE_ALLOW_IMAGE_LIST as Rn, getDrawingShapeKeyByDrawingSearch as Mn, UniverDrawingPlugin as Dn } from "@univerjs/drawing";
-import { IRenderManagerService as K, getGroupState as bn, transformObjectOutOfGroup as En, precisionTo as Q, Rect as yn, DRAWING_OBJECT_LAYER_INDEX as On, SHEET_VIEWPORT_KEY as Pn, RENDER_CLASS_TYPE as ae } from "@univerjs/engine-render";
-import { SheetCanvasPopManagerService as Tn, ISheetSelectionRenderService as Ge, SheetSkeletonManagerService as re, attachRangeWithCoord as Un, getCurrentRangeDisable$ as An, SetScrollOperation as Nn, SetZoomRatioOperation as jn, SheetPrintInterceptorService as Ln, COPY_TYPE as gt, PREDEFINED_HOOK_NAME as Ie, virtualizeDiscreteRanges as Bn, ISheetClipboardService as Wn } from "@univerjs/sheets-ui";
-import { takeUntil as ht, Subject as mt, BehaviorSubject as $n, combineLatest as Re, map as ft, filter as Me, distinctUntilChanged as De } from "rxjs";
-import { ISidebarService as Vn, BuiltInUIPart as Gn, IUIPartsService as xn, IMessageService as Fn, MenuItemType as St, MenuPosition as Yn, MenuGroup as kn, getMenuHiddenObservable as Ct, KeyCode as ue, ComponentManager as Hn, IMenuService as Xn, IShortcutService as zn, CanvasFloatDomService as Kn } from "@univerjs/ui";
-import { useDependency as ee, connectInjector as Jn } from "@wendellhu/redi/react-bindings";
-import { getSheetCommandTarget as le, SheetsSelectionsService as Zn, WorkbookEditablePermission as Ze, WorksheetEditPermission as Pe, RangeProtectionPermissionEditPoint as qn, InsertRowCommand as It, InsertColCommand as Rt, RemoveRowCommand as Mt, RemoveColCommand as Dt, DeleteRangeMoveLeftCommand as bt, DeleteRangeMoveUpCommand as Et, InsertRangeMoveDownCommand as yt, InsertRangeMoveRightCommand as Ot, DeltaRowHeightCommand as qe, SetRowHeightCommand as Qe, DeltaColumnWidthCommand as Pt, SetColWidthCommand as Tt, SetRowHiddenCommand as Ut, SetSpecificRowsVisibleCommand as At, SetSpecificColsVisibleCommand as Nt, SetColHiddenCommand as jt, SetRowVisibleMutation as Qn, SetRowHiddenMutation as er, SetColVisibleMutation as tr, SetColHiddenMutation as nr, SetWorksheetRowHeightMutation as rr, SetWorksheetColWidthMutation as ir, SetWorksheetActiveOperation as sr, SheetInterceptorService as or, SetFrozenMutation as ar, WorkbookViewPermission as pt, WorksheetViewPermission as He } from "@univerjs/sheets";
-import L, { useEffect as rt, forwardRef as Lt, useRef as Bt, createElement as Wt, useState as et } from "react";
-import { MessageType as be, RadioGroup as cr, Radio as Xe } from "@univerjs/design";
-import Ee from "clsx";
-const j = {
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: !0 });
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key != "symbol" ? key + "" : key, value);
+import { CommandType, ICommandService, IUndoRedoService, LocaleService, IUniverInstanceService, useDependency, RxDisposable, UniverInstanceType, connectInjector, toDisposable, FOCUSING_COMMON_DRAWINGS, OnLifecycle, LifecycleStages, Inject, Injector, IContextService, Disposable, Direction, FOCUSING_FORMULA_EDITOR, EDITOR_ACTIVATED, Rectangle, DrawingTypeEnum as DrawingTypeEnum$1, DisposableCollection, Tools, UserManagerService, IPermissionService, Plugin, DependentOn } from "@univerjs/core";
+import { ImageCropperObject, COMPONENT_IMAGE_POPUP_MENU, OpenImageCropOperation, ImageResetSizeOperation, DrawingCommonPanel, DrawingRenderService, UniverDrawingUIPlugin } from "@univerjs/drawing-ui";
+import { ISheetDrawingService, SetDrawingApplyMutation, DrawingApplyType, SheetDrawingAnchorType, UniverSheetsDrawingPlugin } from "@univerjs/sheets-drawing";
+import { IDrawingManagerService, IImageIoService, ArrangeTypeEnum, DrawingTypeEnum, DRAWING_IMAGE_COUNT_LIMIT, ImageUploadStatusType, DRAWING_IMAGE_ALLOW_SIZE, getImageSize, DRAWING_IMAGE_WIDTH_LIMIT, DRAWING_IMAGE_HEIGHT_LIMIT, DRAWING_IMAGE_ALLOW_IMAGE_LIST, getDrawingShapeKeyByDrawingSearch, UniverDrawingPlugin } from "@univerjs/drawing";
+import { IRenderManagerService, getGroupState, transformObjectOutOfGroup, precisionTo, Rect, DRAWING_OBJECT_LAYER_INDEX, SHEET_VIEWPORT_KEY, RENDER_CLASS_TYPE } from "@univerjs/engine-render";
+import { SheetCanvasPopManagerService, attachRangeWithCoord, SheetSkeletonManagerService, ISheetSelectionRenderService, getCurrentRangeDisable$, SetScrollOperation, SetZoomRatioOperation, SheetPrintInterceptorService, COPY_TYPE, PREDEFINED_HOOK_NAME, virtualizeDiscreteRanges, ISheetClipboardService } from "@univerjs/sheets-ui";
+import { takeUntil, Subject, BehaviorSubject, combineLatest, map, filter, distinctUntilChanged } from "rxjs";
+import { ISidebarService, BuiltInUIPart, IUIPartsService, IMessageService, MenuItemType, MenuPosition, MenuGroup, getMenuHiddenObservable, KeyCode, ComponentManager, IMenuService, IShortcutService, CanvasFloatDomService } from "@univerjs/ui";
+import { getSheetCommandTarget, SheetsSelectionsService, WorkbookEditablePermission, WorksheetEditPermission, RangeProtectionPermissionEditPoint, InsertRowCommand, InsertColCommand, RemoveRowCommand, RemoveColCommand, DeleteRangeMoveLeftCommand, DeleteRangeMoveUpCommand, InsertRangeMoveDownCommand, InsertRangeMoveRightCommand, DeltaRowHeightCommand, SetRowHeightCommand, DeltaColumnWidthCommand, SetColWidthCommand, SetRowHiddenCommand, SetSpecificRowsVisibleCommand, SetSpecificColsVisibleCommand, SetColHiddenCommand, SetRowVisibleMutation, SetRowHiddenMutation, SetColVisibleMutation, SetColHiddenMutation, SetWorksheetRowHeightMutation, SetWorksheetColWidthMutation, SetWorksheetActiveOperation, SheetInterceptorService, SetFrozenMutation, WorkbookViewPermission, WorksheetViewPermission } from "@univerjs/sheets";
+import React, { useEffect, forwardRef, useRef, createElement, useState } from "react";
+import { MessageType, RadioGroup, Radio } from "@univerjs/design";
+import clsx from "clsx";
+const ClearSheetDrawingTransformerOperation = {
   id: "sheet.operation.clear-drawing-transformer",
-  type: F.MUTATION,
-  handler: (i, e) => {
-    const n = i.get(K);
-    return e.forEach((t) => {
-      var r, s;
-      (s = (r = n.getRenderById(t)) == null ? void 0 : r.scene.getTransformer()) == null || s.debounceRefreshControls();
+  type: CommandType.MUTATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const renderManagerService = accessor.get(IRenderManagerService);
+    return params.forEach((unitId) => {
+      var _a10, _b;
+      (_b = (_a10 = renderManagerService.getRenderById(unitId)) == null ? void 0 : _a10.scene.getTransformer()) == null || _b.debounceRefreshControls();
     }), !0;
-  }
-}, it = {
+  }, "handler")
+}, RemoveSheetDrawingCommand = {
   id: "sheet.command.remove-sheet-image",
-  type: F.COMMAND,
-  handler: (i, e) => {
-    const n = i.get(V), t = i.get(ge), r = i.get(k);
-    if (!e) return !1;
-    const { drawings: s } = e, o = [];
-    s.forEach((f) => {
-      const { unitId: m } = f;
-      o.push(m);
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), sheetDrawingService = accessor.get(ISheetDrawingService);
+    if (!params) return !1;
+    const { drawings } = params, unitIds = [];
+    drawings.forEach((param) => {
+      const { unitId: unitId2 } = param;
+      unitIds.push(unitId2);
     });
-    const a = r.getBatchRemoveOp(s), { unitId: d, subUnitId: h, undo: l, redo: c, objects: u } = a;
-    return n.syncExecuteCommand(E.id, { unitId: d, subUnitId: h, op: c, objects: u, type: y.REMOVE }) ? (t.pushUndoRedo({
-      unitID: d,
+    const jsonOp = sheetDrawingService.getBatchRemoveOp(drawings), { unitId, subUnitId, undo, redo, objects } = jsonOp;
+    return commandService.syncExecuteCommand(SetDrawingApplyMutation.id, { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.REMOVE }) ? (undoRedoService.pushUndoRedo({
+      unitID: unitId,
       undoMutations: [
-        { id: E.id, params: { unitId: d, subUnitId: h, op: l, objects: u, type: y.INSERT } },
-        { id: j.id, params: o }
+        { id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: undo, objects, type: DrawingApplyType.INSERT } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
       ],
       redoMutations: [
-        { id: E.id, params: { unitId: d, subUnitId: h, op: c, objects: u, type: y.REMOVE } },
-        { id: j.id, params: o }
+        { id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.REMOVE } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
       ]
     }), !0) : !1;
-  }
-}, $t = "COMPONENT_SHEET_DRAWING_PANEL", Vt = {
+  }, "handler")
+}, COMPONENT_SHEET_DRAWING_PANEL = "COMPONENT_SHEET_DRAWING_PANEL", SidebarSheetDrawingOperation = {
   id: "sidebar.operation.sheet-image",
-  type: F.COMMAND,
-  handler: async (i, e) => {
-    const n = i.get(Vn), t = i.get(_e), r = i.get(he), s = i.get(z);
-    if (!le(r)) return !1;
-    switch (e.value) {
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name(async (accessor, params) => {
+    const sidebarService = accessor.get(ISidebarService), localeService = accessor.get(LocaleService), univerInstanceService = accessor.get(IUniverInstanceService), drawingManagerService = accessor.get(IDrawingManagerService);
+    if (!getSheetCommandTarget(univerInstanceService)) return !1;
+    switch (params.value) {
       case "open":
-        n.open({
-          header: { title: t.t("sheetImage.panel.title") },
-          children: { label: $t },
-          onClose: () => {
-            s.focusDrawing(null);
-          },
+        sidebarService.open({
+          header: { title: localeService.t("sheetImage.panel.title") },
+          children: { label: COMPONENT_SHEET_DRAWING_PANEL },
+          onClose: /* @__PURE__ */ __name(() => {
+            drawingManagerService.focusDrawing(null);
+          }, "onClose"),
           width: 360
         });
         break;
       case "close":
       default:
-        n.close();
+        sidebarService.close();
         break;
     }
     return !0;
-  }
-}, Gt = {
+  }, "handler")
+}, EditSheetDrawingOperation = {
   id: "sheet.operation.edit-sheet-image",
-  type: F.OPERATION,
-  handler: (i, e) => {
-    const n = i.get(z), t = i.get(V);
-    return e == null ? !1 : (n.focusDrawing([e]), t.executeCommand(Vt.id, { value: "open" }), !0);
-  }
-}, dr = "univer-upload-loading", lr = "univer-upload-loading-body", ur = "univer-upload-loading-body-animation", gr = "univer-UniverCircleAnimation", hr = "univer-upload-loading-body-text", ye = {
-  uploadLoading: dr,
-  uploadLoadingBody: lr,
-  uploadLoadingBodyAnimation: ur,
-  univerCircleAnimation: gr,
-  uploadLoadingBodyText: hr
-}, mr = () => {
-  const i = ee(vt), e = ee(_e), [n, t] = L.useState(0);
-  return rt(() => {
-    const r = i.change$.subscribe((s) => {
-      t(s);
+  type: CommandType.OPERATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const drawingManagerService = accessor.get(IDrawingManagerService), commandService = accessor.get(ICommandService);
+    return params == null ? !1 : (drawingManagerService.focusDrawing([params]), commandService.executeCommand(SidebarSheetDrawingOperation.id, { value: "open" }), !0);
+  }, "handler")
+}, uploadLoading = "univer-upload-loading", uploadLoadingBody = "univer-upload-loading-body", uploadLoadingBodyAnimation = "univer-upload-loading-body-animation", univerCircleAnimation = "univer-UniverCircleAnimation", uploadLoadingBodyText = "univer-upload-loading-body-text", styles$2 = {
+  uploadLoading,
+  uploadLoadingBody,
+  uploadLoadingBodyAnimation,
+  univerCircleAnimation,
+  uploadLoadingBodyText
+}, UploadLoading = /* @__PURE__ */ __name(() => {
+  const imageIoService = useDependency(IImageIoService), localeService = useDependency(LocaleService), [remain, setRemain] = React.useState(0);
+  return useEffect(() => {
+    const sub = imageIoService.change$.subscribe((count) => {
+      setRemain(count);
     });
     return () => {
-      r.unsubscribe();
+      sub.unsubscribe();
     };
-  }, [i]), /* @__PURE__ */ L.createElement("div", { style: { display: n > 0 ? "block" : "none" }, className: ye.uploadLoading }, /* @__PURE__ */ L.createElement("div", { className: ye.uploadLoadingBody }, /* @__PURE__ */ L.createElement("div", { className: ye.uploadLoadingBodyAnimation }), /* @__PURE__ */ L.createElement("div", { className: ye.uploadLoadingBodyText }, `${e.t("uploadLoading.loading")}: ${n}`)));
-};
-var fr = Object.defineProperty, pr = Object.getOwnPropertyDescriptor, wr = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? pr(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && fr(e, n, r), r;
-}, te = (i, e) => (n, t) => e(n, t, i);
-let Te = class extends nn {
-  constructor(e, n, t, r, s, o, a) {
+  }, [imageIoService]), /* @__PURE__ */ React.createElement("div", { style: { display: remain > 0 ? "block" : "none" }, className: styles$2.uploadLoading }, /* @__PURE__ */ React.createElement("div", { className: styles$2.uploadLoadingBody }, /* @__PURE__ */ React.createElement("div", { className: styles$2.uploadLoadingBodyAnimation }), /* @__PURE__ */ React.createElement("div", { className: styles$2.uploadLoadingBodyText }, `${localeService.t("uploadLoading.loading")}: ${remain}`)));
+}, "UploadLoading");
+var __defProp$8 = Object.defineProperty, __getOwnPropDesc$8 = Object.getOwnPropertyDescriptor, __decorateClass$8 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$8(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$8(target, key, result), result;
+}, "__decorateClass$8"), __decorateParam$8 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$8"), _a;
+let DrawingPopupMenuController = (_a = class extends RxDisposable {
+  constructor(_injector, _drawingManagerService, _canvasPopManagerService, _renderManagerService, _univerInstanceService, _contextService, _uiPartsService) {
     super();
-    H(this, "_initImagePopupMenu", /* @__PURE__ */ new Set());
-    this._injector = e, this._drawingManagerService = n, this._canvasPopManagerService = t, this._renderManagerService = r, this._univerInstanceService = s, this._contextService = o, this._uiPartsService = a, this._init();
+    __publicField(this, "_initImagePopupMenu", /* @__PURE__ */ new Set());
+    this._injector = _injector, this._drawingManagerService = _drawingManagerService, this._canvasPopManagerService = _canvasPopManagerService, this._renderManagerService = _renderManagerService, this._univerInstanceService = _univerInstanceService, this._contextService = _contextService, this._uiPartsService = _uiPartsService, this._init();
   }
   _init() {
-    this._univerInstanceService.getCurrentTypeOfUnit$(B.UNIVER_SHEET).pipe(ht(this.dispose$)).subscribe((e) => this._create(e)), this._univerInstanceService.getTypeOfUnitDisposed$(B.UNIVER_SHEET).pipe(ht(this.dispose$)).subscribe((e) => this._dispose(e)), this._univerInstanceService.getAllUnitsForType(B.UNIVER_SHEET).forEach((e) => this._create(e)), this._uiPartsService.registerComponent(Gn.CONTENT, () => Jn(mr, this._injector));
+    this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_SHEET).pipe(takeUntil(this.dispose$)).subscribe((workbook) => this._create(workbook)), this._univerInstanceService.getTypeOfUnitDisposed$(UniverInstanceType.UNIVER_SHEET).pipe(takeUntil(this.dispose$)).subscribe((workbook) => this._dispose(workbook)), this._univerInstanceService.getAllUnitsForType(UniverInstanceType.UNIVER_SHEET).forEach((workbook) => this._create(workbook)), this._uiPartsService.registerComponent(BuiltInUIPart.CONTENT, () => connectInjector(UploadLoading, this._injector));
   }
-  _dispose(e) {
-    const n = e.getUnitId();
-    this._renderManagerService.removeRender(n);
+  _dispose(workbook) {
+    const unitId = workbook.getUnitId();
+    this._renderManagerService.removeRender(unitId);
   }
-  _create(e) {
-    if (!e)
+  _create(workbook) {
+    if (!workbook)
       return;
-    const n = e.getUnitId();
-    this._renderManagerService.has(n) && !this._initImagePopupMenu.has(n) && (this._popupMenuListener(n), this._initImagePopupMenu.add(n));
+    const unitId = workbook.getUnitId();
+    this._renderManagerService.has(unitId) && !this._initImagePopupMenu.has(unitId) && (this._popupMenuListener(unitId), this._initImagePopupMenu.add(unitId));
   }
-  _hasCropObject(e) {
-    const n = e.getAllObjects();
-    for (const t of n)
-      if (t instanceof hn)
+  _hasCropObject(scene) {
+    const objects = scene.getAllObjects();
+    for (const object of objects)
+      if (object instanceof ImageCropperObject)
         return !0;
     return !1;
   }
-  _popupMenuListener(e) {
-    var s;
-    const n = (s = this._renderManagerService.getRenderById(e)) == null ? void 0 : s.scene;
-    if (!n)
+  _popupMenuListener(unitId) {
+    var _a10;
+    const scene = (_a10 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a10.scene;
+    if (!scene)
       return;
-    const t = n.getTransformerByCreate();
-    if (!t)
+    const transformer = scene.getTransformerByCreate();
+    if (!transformer)
       return;
-    let r;
+    let singletonPopupDisposer;
     this.disposeWithMe(
-      rn(
-        t.createControl$.subscribe(() => {
-          if (this._contextService.setContextValue(we, !0), this._hasCropObject(n))
+      toDisposable(
+        transformer.createControl$.subscribe(() => {
+          if (this._contextService.setContextValue(FOCUSING_COMMON_DRAWINGS, !0), this._hasCropObject(scene))
             return;
-          const o = t.getSelectedObjectMap();
-          if (o.size > 1) {
-            r == null || r.dispose();
+          const selectedObjects = transformer.getSelectedObjectMap();
+          if (selectedObjects.size > 1) {
+            singletonPopupDisposer == null || singletonPopupDisposer.dispose();
             return;
           }
-          const a = o.values().next().value;
-          if (!a)
+          const object = selectedObjects.values().next().value;
+          if (!object)
             return;
-          const d = a.oKey, h = this._drawingManagerService.getDrawingOKey(d);
-          if (!h)
+          const oKey = object.oKey, drawingParam = this._drawingManagerService.getDrawingOKey(oKey);
+          if (!drawingParam)
             return;
-          const { unitId: l, subUnitId: c, drawingId: u } = h;
-          r == null || r.dispose(), r = this.disposeWithMe(this._canvasPopManagerService.attachPopupToObject(a, {
-            componentKey: mn,
+          const { unitId: unitId2, subUnitId, drawingId } = drawingParam;
+          singletonPopupDisposer == null || singletonPopupDisposer.dispose(), singletonPopupDisposer = this.disposeWithMe(this._canvasPopManagerService.attachPopupToObject(object, {
+            componentKey: COMPONENT_IMAGE_POPUP_MENU,
             direction: "horizontal",
             offset: [2, 0],
             extraProps: {
-              menuItems: this._getImageMenuItems(l, c, u)
+              menuItems: this._getImageMenuItems(unitId2, subUnitId, drawingId)
             }
           })), this._drawingManagerService.focusDrawing([{
-            unitId: l,
-            subUnitId: c,
-            drawingId: u
+            unitId: unitId2,
+            subUnitId,
+            drawingId
           }]);
         })
       )
     ), this.disposeWithMe(
-      t.clearControl$.subscribe(() => {
-        r == null || r.dispose(), this._contextService.setContextValue(we, !1), this._drawingManagerService.focusDrawing(null);
+      transformer.clearControl$.subscribe(() => {
+        singletonPopupDisposer == null || singletonPopupDisposer.dispose(), this._contextService.setContextValue(FOCUSING_COMMON_DRAWINGS, !1), this._drawingManagerService.focusDrawing(null);
       })
     ), this.disposeWithMe(
-      t.changing$.subscribe(() => {
-        r == null || r.dispose();
+      transformer.changing$.subscribe(() => {
+        singletonPopupDisposer == null || singletonPopupDisposer.dispose();
       })
     );
   }
-  _getImageMenuItems(e, n, t) {
+  _getImageMenuItems(unitId, subUnitId, drawingId) {
     return [
       {
         label: "image-popup.edit",
         index: 0,
-        commandId: Gt.id,
-        commandParams: { unitId: e, subUnitId: n, drawingId: t },
+        commandId: EditSheetDrawingOperation.id,
+        commandParams: { unitId, subUnitId, drawingId },
         disable: !1
       },
       {
         label: "image-popup.delete",
         index: 1,
-        commandId: it.id,
-        commandParams: { unitId: e, drawings: [{ unitId: e, subUnitId: n, drawingId: t }] },
+        commandId: RemoveSheetDrawingCommand.id,
+        commandParams: { unitId, drawings: [{ unitId, subUnitId, drawingId }] },
         disable: !1
       },
       {
         label: "image-popup.crop",
         index: 2,
-        commandId: fn.id,
-        commandParams: { unitId: e, subUnitId: n, drawingId: t },
+        commandId: OpenImageCropOperation.id,
+        commandParams: { unitId, subUnitId, drawingId },
         disable: !1
       },
       {
         label: "image-popup.reset",
         index: 3,
-        commandId: pn.id,
-        commandParams: [{ unitId: e, subUnitId: n, drawingId: t }],
+        commandId: ImageResetSizeOperation.id,
+        commandParams: [{ unitId, subUnitId, drawingId }],
         disable: !1
       }
     ];
   }
-};
-Te = wr([
-  ie(se.Steady, Te),
-  te(0, W(nt)),
-  te(1, z),
-  te(2, W(Tn)),
-  te(3, K),
-  te(4, he),
-  te(5, _t),
-  te(6, W(xn))
-], Te);
-const xe = {
+}, __name(_a, "DrawingPopupMenuController"), _a);
+DrawingPopupMenuController = __decorateClass$8([
+  OnLifecycle(LifecycleStages.Steady, DrawingPopupMenuController),
+  __decorateParam$8(0, Inject(Injector)),
+  __decorateParam$8(1, IDrawingManagerService),
+  __decorateParam$8(2, Inject(SheetCanvasPopManagerService)),
+  __decorateParam$8(3, IRenderManagerService),
+  __decorateParam$8(4, IUniverInstanceService),
+  __decorateParam$8(5, IContextService),
+  __decorateParam$8(6, Inject(IUIPartsService))
+], DrawingPopupMenuController);
+const InsertFloatImageOperation = {
   id: "sheet.operation.insert-float-image",
-  type: F.OPERATION,
-  handler: (i, e) => !0
-}, Be = {
+  type: CommandType.OPERATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => !0, "handler")
+}, InsertCellImageOperation = {
   id: "sheet.operation.insert-cell-image",
-  type: F.OPERATION,
-  handler: (i, e) => !0
-}, st = {
+  type: CommandType.OPERATION,
+  handler: /* @__PURE__ */ __name((accessor, params) => !0, "handler")
+}, InsertSheetDrawingCommand = {
   id: "sheet.command.insert-sheet-image",
-  type: F.COMMAND,
-  handler: (i, e) => {
-    const n = i.get(V), t = i.get(ge), r = i.get(k);
-    if (!e) return !1;
-    const s = e.drawings, o = s.map((f) => f.unitId), a = r.getBatchAddOp(s), { unitId: d, subUnitId: h, undo: l, redo: c, objects: u } = a;
-    return n.syncExecuteCommand(E.id, { op: c, unitId: d, subUnitId: h, objects: u, type: y.INSERT }) ? (t.pushUndoRedo({
-      unitID: d,
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), sheetDrawingService = accessor.get(ISheetDrawingService);
+    if (!params) return !1;
+    const drawings = params.drawings, unitIds = drawings.map((param) => param.unitId), jsonOp = sheetDrawingService.getBatchAddOp(drawings), { unitId, subUnitId, undo, redo, objects } = jsonOp;
+    return commandService.syncExecuteCommand(SetDrawingApplyMutation.id, { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.INSERT }) ? (undoRedoService.pushUndoRedo({
+      unitID: unitId,
       undoMutations: [
-        { id: E.id, params: { op: l, unitId: d, subUnitId: h, objects: u, type: y.REMOVE } },
-        { id: j.id, params: o }
+        { id: SetDrawingApplyMutation.id, params: { op: undo, unitId, subUnitId, objects, type: DrawingApplyType.REMOVE } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
       ],
       redoMutations: [
-        { id: E.id, params: { op: c, unitId: d, subUnitId: h, objects: u, type: y.INSERT } },
-        { id: j.id, params: o }
+        { id: SetDrawingApplyMutation.id, params: { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.INSERT } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
       ]
     }), !0) : !1;
-  }
-}, Fe = {
+  }, "handler")
+}, SetSheetDrawingCommand = {
   id: "sheet.command.set-sheet-image",
-  type: F.COMMAND,
-  handler: (i, e) => {
-    const n = i.get(V), t = i.get(ge), r = i.get(k);
-    if (!e) return !1;
-    const { drawings: s } = e, o = r.getBatchUpdateOp(s), { unitId: a, subUnitId: d, undo: h, redo: l, objects: c } = o;
-    return n.syncExecuteCommand(E.id, { unitId: a, subUnitId: d, op: l, objects: c, type: y.UPDATE }) ? (t.pushUndoRedo({
-      unitID: a,
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), sheetDrawingService = accessor.get(ISheetDrawingService);
+    if (!params) return !1;
+    const { drawings } = params, jsonOp = sheetDrawingService.getBatchUpdateOp(drawings), { unitId, subUnitId, undo, redo, objects } = jsonOp;
+    return commandService.syncExecuteCommand(SetDrawingApplyMutation.id, { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.UPDATE }) ? (undoRedoService.pushUndoRedo({
+      unitID: unitId,
       undoMutations: [
-        { id: E.id, params: { unitId: a, subUnitId: d, op: h, objects: c, type: y.UPDATE } },
-        { id: j.id, params: [a] }
+        { id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: undo, objects, type: DrawingApplyType.UPDATE } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }
       ],
       redoMutations: [
-        { id: E.id, params: { unitId: a, subUnitId: d, op: l, objects: c, type: y.UPDATE } },
-        { id: j.id, params: [a] }
+        { id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.UPDATE } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }
       ]
     }), !0) : !1;
-  }
-}, xt = {
+  }, "handler")
+}, SetDrawingArrangeCommand = {
   id: "sheet.command.set-drawing-arrange",
-  type: F.COMMAND,
-  handler: (i, e) => {
-    const n = i.get(V), t = i.get(ge);
-    if (!e) return !1;
-    const r = i.get(k), { unitId: s, subUnitId: o, drawingIds: a, arrangeType: d } = e, h = { unitId: s, subUnitId: o, drawingIds: a };
-    let l;
-    if (d === Ce.forward ? l = r.getForwardDrawingsOp(h) : d === Ce.backward ? l = r.getBackwardDrawingOp(h) : d === Ce.front ? l = r.getFrontDrawingsOp(h) : d === Ce.back && (l = r.getBackDrawingsOp(h)), l == null)
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService);
+    if (!params) return !1;
+    const sheetDrawingService = accessor.get(ISheetDrawingService), { unitId, subUnitId, drawingIds, arrangeType } = params, drawingOrderMapParam = { unitId, subUnitId, drawingIds };
+    let jsonOp;
+    if (arrangeType === ArrangeTypeEnum.forward ? jsonOp = sheetDrawingService.getForwardDrawingsOp(drawingOrderMapParam) : arrangeType === ArrangeTypeEnum.backward ? jsonOp = sheetDrawingService.getBackwardDrawingOp(drawingOrderMapParam) : arrangeType === ArrangeTypeEnum.front ? jsonOp = sheetDrawingService.getFrontDrawingsOp(drawingOrderMapParam) : arrangeType === ArrangeTypeEnum.back && (jsonOp = sheetDrawingService.getBackDrawingsOp(drawingOrderMapParam)), jsonOp == null)
       return !1;
-    const { objects: c, redo: u, undo: g } = l;
-    return n.syncExecuteCommand(E.id, { op: u, unitId: s, subUnitId: o, objects: c, type: y.ARRANGE }) ? (t.pushUndoRedo({
-      unitID: s,
+    const { objects, redo, undo } = jsonOp;
+    return commandService.syncExecuteCommand(SetDrawingApplyMutation.id, { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.ARRANGE }) ? (undoRedoService.pushUndoRedo({
+      unitID: unitId,
       undoMutations: [
-        { id: E.id, params: { op: g, unitId: s, subUnitId: o, objects: c, type: y.ARRANGE } }
+        { id: SetDrawingApplyMutation.id, params: { op: undo, unitId, subUnitId, objects, type: DrawingApplyType.ARRANGE } }
       ],
       redoMutations: [
-        { id: E.id, params: { op: u, unitId: s, subUnitId: o, objects: c, type: y.ARRANGE } }
+        { id: SetDrawingApplyMutation.id, params: { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.ARRANGE } }
       ]
     }), !0) : !1;
-  }
+  }, "handler")
 };
-function _r(i) {
-  const e = [];
-  return i.forEach((n) => {
-    const { parent: t, children: r } = n, { unitId: s, subUnitId: o, drawingId: a } = t, d = bn(0, 0, r.map((c) => c.transform || {})), h = r.map((c) => {
-      const u = c.transform || { left: 0, top: 0 }, { unitId: g, subUnitId: f, drawingId: m } = c;
+function ungroupToGroup(ungroupParams) {
+  const newGroupParams = [];
+  return ungroupParams.forEach((ungroupParam) => {
+    const { parent, children } = ungroupParam, { unitId, subUnitId, drawingId: groupId } = parent, groupTransform = getGroupState(0, 0, children.map((o) => o.transform || {})), newChildren = children.map((drawing) => {
+      const transform = drawing.transform || { left: 0, top: 0 }, { unitId: unitId2, subUnitId: subUnitId2, drawingId } = drawing;
       return {
-        unitId: g,
-        subUnitId: f,
-        drawingId: m,
+        unitId: unitId2,
+        subUnitId: subUnitId2,
+        drawingId,
         transform: {
-          ...u,
-          left: u.left - d.left,
-          top: u.top - d.top
+          ...transform,
+          left: transform.left - groupTransform.left,
+          top: transform.top - groupTransform.top
         },
-        groupId: a
+        groupId
       };
-    }), l = {
-      unitId: s,
-      subUnitId: o,
-      drawingId: a,
-      drawingType: Ve.DRAWING_GROUP,
-      transform: d
+    }), groupParam = {
+      unitId,
+      subUnitId,
+      drawingId: groupId,
+      drawingType: DrawingTypeEnum.DRAWING_GROUP,
+      transform: groupTransform
     };
-    e.push({
-      parent: l,
-      children: h
+    newGroupParams.push({
+      parent: groupParam,
+      children: newChildren
     });
-  }), e;
+  }), newGroupParams;
 }
-function vr(i) {
-  const e = [];
-  return i.forEach((n) => {
-    const { parent: t, children: r } = n, { unitId: s, subUnitId: o, drawingId: a, transform: d = { width: 0, height: 0 } } = t;
-    if (d == null)
+__name(ungroupToGroup, "ungroupToGroup");
+function groupToUngroup(groupParams) {
+  const newGroupParams = [];
+  return groupParams.forEach((groupParam) => {
+    const { parent, children } = groupParam, { unitId, subUnitId, drawingId: groupId, transform: groupTransform = { width: 0, height: 0 } } = parent;
+    if (groupTransform == null)
       return;
-    const h = r.map((c) => {
-      const { transform: u } = c, { unitId: g, subUnitId: f, drawingId: m } = c, p = En(u || {}, d, d.width || 0, d.height || 0);
+    const newChildren = children.map((object) => {
+      const { transform } = object, { unitId: unitId2, subUnitId: subUnitId2, drawingId } = object, newTransform = transformObjectOutOfGroup(transform || {}, groupTransform, groupTransform.width || 0, groupTransform.height || 0);
       return {
-        unitId: g,
-        subUnitId: f,
-        drawingId: m,
-        transform: p,
+        unitId: unitId2,
+        subUnitId: subUnitId2,
+        drawingId,
+        transform: newTransform,
         groupId: void 0
       };
-    }), l = {
-      unitId: s,
-      subUnitId: o,
-      drawingId: a,
-      drawingType: Ve.DRAWING_GROUP,
+    }), ungroupParam = {
+      unitId,
+      subUnitId,
+      drawingId: groupId,
+      drawingType: DrawingTypeEnum.DRAWING_GROUP,
       transform: {
         left: 0,
         top: 0
       }
     };
-    e.push({
-      parent: l,
-      children: h
+    newGroupParams.push({
+      parent: ungroupParam,
+      children: newChildren
     });
-  }), e;
+  }), newGroupParams;
 }
-const Ft = {
+__name(groupToUngroup, "groupToUngroup");
+const GroupSheetDrawingCommand = {
   id: "sheet.command.group-sheet-image",
-  type: F.COMMAND,
-  handler: (i, e) => {
-    const n = i.get(V), t = i.get(ge), r = i.get(k);
-    if (!e) return !1;
-    const s = [];
-    e.forEach(({ parent: g, children: f }) => {
-      s.push(g.unitId), f.forEach((m) => {
-        s.push(m.unitId);
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), sheetDrawingService = accessor.get(ISheetDrawingService);
+    if (!params) return !1;
+    const unitIds = [];
+    params.forEach(({ parent, children }) => {
+      unitIds.push(parent.unitId), children.forEach((child) => {
+        unitIds.push(child.unitId);
       });
     });
-    const o = r.getGroupDrawingOp(e), { unitId: a, subUnitId: d, undo: h, redo: l, objects: c } = o;
-    return n.syncExecuteCommand(E.id, { op: l, unitId: a, subUnitId: d, objects: c, type: y.GROUP }) ? (t.pushUndoRedo({
-      unitID: a,
+    const jsonOp = sheetDrawingService.getGroupDrawingOp(params), { unitId, subUnitId, undo, redo, objects } = jsonOp;
+    return commandService.syncExecuteCommand(SetDrawingApplyMutation.id, { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.GROUP }) ? (undoRedoService.pushUndoRedo({
+      unitID: unitId,
       undoMutations: [
-        { id: E.id, params: { op: h, unitId: a, subUnitId: d, objects: vr(c), type: y.UNGROUP } },
-        { id: j.id, params: s }
+        { id: SetDrawingApplyMutation.id, params: { op: undo, unitId, subUnitId, objects: groupToUngroup(objects), type: DrawingApplyType.UNGROUP } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
       ],
       redoMutations: [
-        { id: E.id, params: { op: l, unitId: a, subUnitId: d, objects: c, type: y.GROUP } },
-        { id: j.id, params: s }
+        { id: SetDrawingApplyMutation.id, params: { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.GROUP } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
       ]
     }), !0) : !1;
-  }
-}, Yt = {
+  }, "handler")
+}, UngroupSheetDrawingCommand = {
   id: "sheet.command.ungroup-sheet-image",
-  type: F.COMMAND,
-  handler: (i, e) => {
-    const n = i.get(V), t = i.get(ge), r = i.get(k);
-    if (!e) return !1;
-    const s = [];
-    e.forEach(({ parent: g, children: f }) => {
-      s.push(g.unitId), f.forEach((m) => {
-        s.push(m.unitId);
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const commandService = accessor.get(ICommandService), undoRedoService = accessor.get(IUndoRedoService), sheetDrawingService = accessor.get(ISheetDrawingService);
+    if (!params) return !1;
+    const unitIds = [];
+    params.forEach(({ parent, children }) => {
+      unitIds.push(parent.unitId), children.forEach((child) => {
+        unitIds.push(child.unitId);
       });
     });
-    const o = r.getUngroupDrawingOp(e), { unitId: a, subUnitId: d, undo: h, redo: l, objects: c } = o;
-    return n.syncExecuteCommand(E.id, { op: l, unitId: a, subUnitId: d, objects: c, type: y.UNGROUP }) ? (t.pushUndoRedo({
-      unitID: a,
+    const jsonOp = sheetDrawingService.getUngroupDrawingOp(params), { unitId, subUnitId, undo, redo, objects } = jsonOp;
+    return commandService.syncExecuteCommand(SetDrawingApplyMutation.id, { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.UNGROUP }) ? (undoRedoService.pushUndoRedo({
+      unitID: unitId,
       undoMutations: [
-        { id: E.id, params: { op: h, unitId: a, subUnitId: d, objects: _r(c), type: y.GROUP } },
-        { id: j.id, params: s }
+        { id: SetDrawingApplyMutation.id, params: { op: undo, unitId, subUnitId, objects: ungroupToGroup(objects), type: DrawingApplyType.GROUP } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
       ],
       redoMutations: [
-        { id: E.id, params: { op: l, unitId: a, subUnitId: d, objects: c, type: y.UNGROUP } },
-        { id: j.id, params: s }
+        { id: SetDrawingApplyMutation.id, params: { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.UNGROUP } },
+        { id: ClearSheetDrawingTransformerOperation.id, params: unitIds }
       ]
     }), !0) : !1;
-  }
+  }, "handler")
 };
-function $(i, e, n) {
-  const { from: t, to: r, flipY: s = !1, flipX: o = !1, angle: a = 0, skewX: d = 0, skewY: h = 0 } = i, { column: l, columnOffset: c, row: u, rowOffset: g } = t, { column: f, columnOffset: m, row: p, rowOffset: S } = r, C = n.attachRangeWithCoord({
-    startColumn: l,
-    endColumn: l,
-    startRow: u,
-    endRow: u
+function drawingPositionToTransform(position, selectionRenderService, sheetSkeletonManagerService) {
+  const { from, to, flipY = !1, flipX = !1, angle = 0, skewX = 0, skewY = 0 } = position, { column: fromColumn, columnOffset: fromColumnOffset, row: fromRow, rowOffset: fromRowOffset } = from, { column: toColumn, columnOffset: toColumnOffset, row: toRow, rowOffset: toRowOffset } = to, startSelectionCell = sheetSkeletonManagerService.attachRangeWithCoord({
+    startColumn: fromColumn,
+    endColumn: fromColumn,
+    startRow: fromRow,
+    endRow: fromRow
   });
-  if (C == null)
+  if (startSelectionCell == null)
     return;
-  const v = n.attachRangeWithCoord({
-    startColumn: f,
-    endColumn: f,
-    startRow: p,
-    endRow: p
+  const endSelectionCell = sheetSkeletonManagerService.attachRangeWithCoord({
+    startColumn: toColumn,
+    endColumn: toColumn,
+    startRow: toRow,
+    endRow: toRow
   });
-  if (v == null)
+  if (endSelectionCell == null)
     return;
-  const { startX: R, startY: _ } = C, { startX: b, startY: w } = v;
-  let P = Q(R + c, 1), D = Q(_ + g, 1), T = Q(b + m - P, 1), U = Q(w + S - D, 1);
-  C.startX === v.endX && (T = 0), C.startY === v.endY && (U = 0);
-  const M = n.getCurrentSkeleton(), I = M.rowHeaderWidth + M.columnTotalWidth, A = M.columnHeaderHeight + M.rowTotalHeight;
-  return P + T > I && (P = I - T), D + U > A && (D = A - U), {
-    flipY: s,
-    flipX: o,
-    angle: a,
-    skewX: d,
-    skewY: h,
-    left: P,
-    top: D,
-    width: T,
-    height: U
+  const { startX: startSelectionX, startY: startSelectionY } = startSelectionCell, { startX: endSelectionX, startY: endSelectionY } = endSelectionCell;
+  let left = precisionTo(startSelectionX + fromColumnOffset, 1), top = precisionTo(startSelectionY + fromRowOffset, 1), width = precisionTo(endSelectionX + toColumnOffset - left, 1), height = precisionTo(endSelectionY + toRowOffset - top, 1);
+  startSelectionCell.startX === endSelectionCell.endX && (width = 0), startSelectionCell.startY === endSelectionCell.endY && (height = 0);
+  const skeleton = sheetSkeletonManagerService.getCurrentSkeleton(), sheetWidth = skeleton.rowHeaderWidth + skeleton.columnTotalWidth, sheetHeight = skeleton.columnHeaderHeight + skeleton.rowTotalHeight;
+  return left + width > sheetWidth && (left = sheetWidth - width), top + height > sheetHeight && (top = sheetHeight - height), {
+    flipY,
+    flipX,
+    angle,
+    skewX,
+    skewY,
+    left,
+    top,
+    width,
+    height
   };
 }
-function N(i, e) {
-  const { left: n = 0, top: t = 0, width: r = 0, height: s = 0, flipY: o = !1, flipX: a = !1, angle: d = 0, skewX: h = 0, skewY: l = 0 } = i, c = e.getSelectionCellByPosition(n, t);
-  if (c == null)
+__name(drawingPositionToTransform, "drawingPositionToTransform");
+function transformToDrawingPosition(transform, selectionRenderService) {
+  const { left = 0, top = 0, width = 0, height = 0, flipY = !1, flipX = !1, angle = 0, skewX = 0, skewY = 0 } = transform, startSelectionCell = selectionRenderService.getSelectionCellByPosition(left, top);
+  if (startSelectionCell == null)
     return;
-  const u = {
-    column: c.actualColumn,
-    columnOffset: Q(n - c.startX, 1),
-    row: c.actualRow,
-    rowOffset: Q(t - c.startY, 1)
-  }, g = e.getSelectionCellByPosition(n + r, t + s);
-  if (g == null)
+  const from = {
+    column: startSelectionCell.actualColumn,
+    columnOffset: precisionTo(left - startSelectionCell.startX, 1),
+    row: startSelectionCell.actualRow,
+    rowOffset: precisionTo(top - startSelectionCell.startY, 1)
+  }, endSelectionCell = selectionRenderService.getSelectionCellByPosition(left + width, top + height);
+  if (endSelectionCell == null)
     return;
-  const f = {
-    column: g.actualColumn,
-    columnOffset: Q(n + r - g.startX, 1),
-    row: g.actualRow,
-    rowOffset: Q(t + s - g.startY, 1)
+  const to = {
+    column: endSelectionCell.actualColumn,
+    columnOffset: precisionTo(left + width - endSelectionCell.startX, 1),
+    row: endSelectionCell.actualRow,
+    rowOffset: precisionTo(top + height - endSelectionCell.startY, 1)
   };
   return {
-    flipY: o,
-    flipX: a,
-    angle: d,
-    skewX: h,
-    skewY: l,
-    from: u,
-    to: f
+    flipY,
+    flipX,
+    angle,
+    skewX,
+    skewY,
+    from,
+    to
   };
 }
-var Sr = Object.defineProperty, Cr = Object.getOwnPropertyDescriptor, Ir = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? Cr(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && Sr(e, n, r), r;
-}, X = (i, e) => (n, t) => e(n, t, i);
-let Ue = class extends oe {
-  constructor(i, e, n, t, r, s, o, a, d, h) {
-    super(), this._commandService = i, this._univerInstanceService = e, this._selectionManagerService = n, this._imageIoService = t, this._sheetDrawingService = r, this._drawingManagerService = s, this._contextService = o, this._messageService = a, this._localeService = d, this._renderManagerService = h, this._init();
-  }
-  // TODO@wzhudev: selection render service would be a render unit, we we cannot
-  // easily access it here.
-  get _selectionRenderService() {
-    return this._renderManagerService.getRenderById(
-      this._univerInstanceService.getCurrentUnitForType(B.UNIVER_SHEET).getUnitId()
-    ).with(Ge);
-  }
-  get _skeletonManagerService() {
-    return this._renderManagerService.getRenderById(
-      this._univerInstanceService.getCurrentUnitForType(B.UNIVER_SHEET).getUnitId()
-    ).with(re);
-  }
-  _init() {
-    this._initCommandListeners(), this._updateImageListener(), this._updateOrderListener(), this._groupDrawingListener(), this._focusDrawingListener(), this._drawingAddListener();
+__name(transformToDrawingPosition, "transformToDrawingPosition");
+var __defProp$7 = Object.defineProperty, __getOwnPropDesc$7 = Object.getOwnPropertyDescriptor, __decorateClass$7 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$7(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$7(target, key, result), result;
+}, "__decorateClass$7"), __decorateParam$7 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$7"), _a2;
+let SheetDrawingUpdateController = (_a2 = class extends Disposable {
+  constructor(_context, _skeletonManagerService, _commandService, _selectionRenderService, _imageIoService, _sheetDrawingService, _drawingManagerService, _contextService, _messageService, _localeService, selectionManagerService) {
+    super();
+    __publicField(this, "_workbookSelections");
+    this._context = _context, this._skeletonManagerService = _skeletonManagerService, this._commandService = _commandService, this._selectionRenderService = _selectionRenderService, this._imageIoService = _imageIoService, this._sheetDrawingService = _sheetDrawingService, this._drawingManagerService = _drawingManagerService, this._contextService = _contextService, this._messageService = _messageService, this._localeService = _localeService, this._workbookSelections = selectionManagerService.getWorkbookSelections(this._context.unitId), this._initCommandListeners(), this._updateImageListener(), this._updateOrderListener(), this._groupDrawingListener(), this._focusDrawingListener(), this._drawingAddListener();
   }
   /**
    * Upload image to cell or float image
    */
   _initCommandListeners() {
     this.disposeWithMe(
-      this._commandService.onCommandExecuted(async (i) => {
-        if (i.id === Be.id || i.id === xe.id) {
-          const e = i.params;
-          if (e.files == null)
+      this._commandService.onCommandExecuted(async (command) => {
+        if (command.id === InsertCellImageOperation.id || command.id === InsertFloatImageOperation.id) {
+          const params = command.params;
+          if (params.files == null)
             return;
-          const n = e.files.length;
-          if (n > dt) {
+          const fileLength = params.files.length;
+          if (fileLength > DRAWING_IMAGE_COUNT_LIMIT) {
             this._messageService.show({
-              type: be.Error,
-              content: this._localeService.t("update-status.exceedMaxCount", String(dt))
+              type: MessageType.Error,
+              content: this._localeService.t("update-status.exceedMaxCount", String(DRAWING_IMAGE_COUNT_LIMIT))
             });
             return;
           }
-          this._imageIoService.setWaitCount(n), i.id === Be.id ? e.files.forEach(async (t) => {
-            await this._insertCellImage(t);
-          }) : e.files.forEach(async (t) => {
-            await this._insertFloatImage(t);
+          this._imageIoService.setWaitCount(fileLength), command.id === InsertCellImageOperation.id ? params.files.forEach(async (file) => {
+            await this._insertCellImage(file);
+          }) : params.files.forEach(async (file) => {
+            await this._insertFloatImage(file);
           });
         }
       })
     );
   }
-  async _insertCellImage(i) {
+  async _insertCellImage(file) {
   }
-  async _insertFloatImage(i) {
-    let e;
+  async _insertFloatImage(file) {
+    let imageParam;
     try {
-      e = await this._imageIoService.saveImage(i);
-    } catch (C) {
-      const v = C.message;
-      v === ke.ERROR_EXCEED_SIZE ? this._messageService.show({
-        type: be.Error,
-        content: this._localeService.t("update-status.exceedMaxSize", String(Cn / (1024 * 1024)))
-      }) : v === ke.ERROR_IMAGE_TYPE ? this._messageService.show({
-        type: be.Error,
+      imageParam = await this._imageIoService.saveImage(file);
+    } catch (error) {
+      const type = error.message;
+      type === ImageUploadStatusType.ERROR_EXCEED_SIZE ? this._messageService.show({
+        type: MessageType.Error,
+        content: this._localeService.t("update-status.exceedMaxSize", String(DRAWING_IMAGE_ALLOW_SIZE / (1024 * 1024)))
+      }) : type === ImageUploadStatusType.ERROR_IMAGE_TYPE ? this._messageService.show({
+        type: MessageType.Error,
         content: this._localeService.t("update-status.invalidImageType")
-      }) : v === ke.ERROR_IMAGE && this._messageService.show({
-        type: be.Error,
+      }) : type === ImageUploadStatusType.ERROR_IMAGE && this._messageService.show({
+        type: MessageType.Error,
         content: this._localeService.t("update-status.invalidImage")
       });
     }
-    if (e == null)
-      return;
-    const n = this._getUnitInfo();
-    if (n == null)
+    if (imageParam == null)
       return;
-    const { unitId: t, subUnitId: r } = n, { imageId: s, imageSourceType: o, source: a, base64Cache: d } = e, { width: h, height: l, image: c } = await In(d || ""), u = this._renderManagerService.getRenderById(t);
-    if (u == null)
+    const info = this._getUnitInfo();
+    if (info == null)
       return;
-    const { width: g, height: f } = u.scene;
-    this._imageIoService.addImageSourceCache(a, o, c);
-    let m = 1;
-    if (h > lt || l > ut) {
-      const C = lt / h, v = ut / l;
-      m = Math.max(C, v);
+    const { unitId, subUnitId } = info, { imageId, imageSourceType, source, base64Cache } = imageParam, { width, height, image } = await getImageSize(base64Cache || ""), { width: sceneWidth, height: sceneHeight } = this._context.scene;
+    this._imageIoService.addImageSourceCache(source, imageSourceType, image);
+    let scale = 1;
+    if (width > DRAWING_IMAGE_WIDTH_LIMIT || height > DRAWING_IMAGE_HEIGHT_LIMIT) {
+      const scaleWidth = DRAWING_IMAGE_WIDTH_LIMIT / width, scaleHeight = DRAWING_IMAGE_HEIGHT_LIMIT / height;
+      scale = Math.max(scaleWidth, scaleHeight);
     }
-    const p = this._getImagePosition(h * m, l * m, g, f);
-    if (p == null)
+    const sheetTransform = this._getImagePosition(width * scale, height * scale, sceneWidth, sceneHeight);
+    if (sheetTransform == null)
       return;
-    const S = {
-      unitId: t,
-      subUnitId: r,
-      drawingId: s,
-      drawingType: Ve.DRAWING_IMAGE,
-      imageSourceType: o,
-      source: a,
-      transform: $(p, this._selectionRenderService, this._skeletonManagerService),
-      sheetTransform: p
+    const sheetDrawingParam = {
+      unitId,
+      subUnitId,
+      drawingId: imageId,
+      drawingType: DrawingTypeEnum.DRAWING_IMAGE,
+      imageSourceType,
+      source,
+      transform: drawingPositionToTransform(sheetTransform, this._selectionRenderService, this._skeletonManagerService),
+      sheetTransform
     };
-    this._commandService.executeCommand(st.id, {
-      unitId: t,
-      drawings: [S]
+    this._commandService.executeCommand(InsertSheetDrawingCommand.id, {
+      unitId,
+      drawings: [sheetDrawingParam]
     });
   }
   _getUnitInfo() {
-    const i = this._univerInstanceService.getCurrentUnitForType(B.UNIVER_SHEET);
-    if (i == null)
-      return;
-    const e = i.getActiveSheet();
-    if (e == null)
-      return;
-    const n = i.getUnitId(), t = e.getSheetId();
+    const workbook = this._context.unit, worksheet = workbook.getActiveSheet(), unitId = workbook.getUnitId(), subUnitId = worksheet.getSheetId();
     return {
-      unitId: n,
-      subUnitId: t
+      unitId,
+      subUnitId
     };
   }
-  _getImagePosition(i, e, n, t) {
-    const r = this._selectionManagerService.getCurrentSelections();
-    let s = {
+  _getImagePosition(imageWidth, imageHeight, sceneWidth, sceneHeight) {
+    const selections = this._workbookSelections.getCurrentSelections();
+    let range = {
       startRow: 0,
       endRow: 0,
       startColumn: 0,
       endColumn: 0
     };
-    r && r.length > 0 && (s = r[r.length - 1].range);
-    const o = Un(this._skeletonManagerService.getCurrent().skeleton, s);
-    if (o == null)
+    selections && selections.length > 0 && (range = selections[selections.length - 1].range);
+    const rangeWithCoord = attachRangeWithCoord(this._skeletonManagerService.getCurrent().skeleton, range);
+    if (rangeWithCoord == null)
       return;
-    let { startColumn: a, startRow: d, startX: h, startY: l } = o, c = !1;
-    if (h + i > n && (h = n - i, h < 0 && (h = 0, i = n), c = !0), l + e > t && (l = t - e, l < 0 && (l = 0, e = t), c = !0), c) {
-      const m = this._selectionRenderService.getSelectionCellByPosition(h, l);
-      if (m == null)
+    let { startColumn, startRow, startX, startY } = rangeWithCoord, isChangeStart = !1;
+    if (startX + imageWidth > sceneWidth && (startX = sceneWidth - imageWidth, startX < 0 && (startX = 0, imageWidth = sceneWidth), isChangeStart = !0), startY + imageHeight > sceneHeight && (startY = sceneHeight - imageHeight, startY < 0 && (startY = 0, imageHeight = sceneHeight), isChangeStart = !0), isChangeStart) {
+      const newCoord = this._selectionRenderService.getSelectionCellByPosition(startX, startY);
+      if (newCoord == null)
         return;
-      h = m.startX, l = m.startY, a = m.actualColumn, d = m.actualRow;
+      startX = newCoord.startX, startY = newCoord.startY, startColumn = newCoord.actualColumn, startRow = newCoord.actualRow;
     }
-    const u = {
-      column: a,
+    const from = {
+      column: startColumn,
       columnOffset: 0,
-      row: d,
+      row: startRow,
       rowOffset: 0
-    }, g = this._selectionRenderService.getSelectionCellByPosition(h + i, l + e);
-    if (g == null)
+    }, endSelectionCell = this._selectionRenderService.getSelectionCellByPosition(startX + imageWidth, startY + imageHeight);
+    if (endSelectionCell == null)
       return;
-    const f = {
-      column: g.actualColumn,
-      columnOffset: h + i - g.startX,
-      row: g.actualRow,
-      rowOffset: l + e - g.startY
+    const to = {
+      column: endSelectionCell.actualColumn,
+      columnOffset: startX + imageWidth - endSelectionCell.startX,
+      row: endSelectionCell.actualRow,
+      rowOffset: startY + imageHeight - endSelectionCell.startY
     };
     return {
-      from: u,
-      to: f
+      from,
+      to
     };
   }
   _updateOrderListener() {
-    this._drawingManagerService.featurePluginOrderUpdate$.subscribe((i) => {
-      const { unitId: e, subUnitId: n, drawingIds: t, arrangeType: r } = i;
-      this._commandService.executeCommand(xt.id, {
-        unitId: e,
-        subUnitId: n,
-        drawingIds: t,
-        arrangeType: r
+    this._drawingManagerService.featurePluginOrderUpdate$.subscribe((params) => {
+      const { unitId, subUnitId, drawingIds, arrangeType } = params;
+      this._commandService.executeCommand(SetDrawingArrangeCommand.id, {
+        unitId,
+        subUnitId,
+        drawingIds,
+        arrangeType
       });
     });
   }
   _updateImageListener() {
-    this._drawingManagerService.featurePluginUpdate$.subscribe((i) => {
-      const e = [];
-      i.length !== 0 && (i.forEach((n) => {
-        const { unitId: t, subUnitId: r, drawingId: s, drawingType: o, transform: a } = n;
-        if (a == null)
+    this._drawingManagerService.featurePluginUpdate$.subscribe((params) => {
+      const drawings = [];
+      params.length !== 0 && (params.forEach((param) => {
+        const { unitId, subUnitId, drawingId, drawingType, transform } = param;
+        if (transform == null)
           return;
-        const d = this._sheetDrawingService.getDrawingByParam({ unitId: t, subUnitId: r, drawingId: s });
-        if (d == null)
+        const sheetDrawing = this._sheetDrawingService.getDrawingByParam({ unitId, subUnitId, drawingId });
+        if (sheetDrawing == null)
           return;
-        const h = N({ ...d.transform, ...a }, this._selectionRenderService);
-        if (h == null)
+        const sheetTransform = transformToDrawingPosition({ ...sheetDrawing.transform, ...transform }, this._selectionRenderService);
+        if (sheetTransform == null)
           return;
-        const l = {
-          ...n,
-          transform: { ...d.transform, ...a, ...$(h, this._selectionRenderService, this._skeletonManagerService) },
-          sheetTransform: { ...h }
+        const newDrawing = {
+          ...param,
+          transform: { ...sheetDrawing.transform, ...transform, ...drawingPositionToTransform(sheetTransform, this._selectionRenderService, this._skeletonManagerService) },
+          sheetTransform: { ...sheetTransform }
         };
-        e.push(l);
-      }), e.length > 0 && this._commandService.executeCommand(Fe.id, {
-        unitId: i[0].unitId,
-        drawings: e
+        drawings.push(newDrawing);
+      }), drawings.length > 0 && this._commandService.executeCommand(SetSheetDrawingCommand.id, {
+        unitId: params[0].unitId,
+        drawings
       }));
     });
   }
   _groupDrawingListener() {
-    this._drawingManagerService.featurePluginGroupUpdate$.subscribe((i) => {
-      this._commandService.executeCommand(Ft.id, i);
-      const { unitId: e, subUnitId: n, drawingId: t } = i[0].parent;
-      this._drawingManagerService.focusDrawing([{ unitId: e, subUnitId: n, drawingId: t }]);
-    }), this._drawingManagerService.featurePluginUngroupUpdate$.subscribe((i) => {
-      this._commandService.executeCommand(Yt.id, i);
+    this._drawingManagerService.featurePluginGroupUpdate$.subscribe((params) => {
+      this._commandService.executeCommand(GroupSheetDrawingCommand.id, params);
+      const { unitId, subUnitId, drawingId } = params[0].parent;
+      this._drawingManagerService.focusDrawing([{ unitId, subUnitId, drawingId }]);
+    }), this._drawingManagerService.featurePluginUngroupUpdate$.subscribe((params) => {
+      this._commandService.executeCommand(UngroupSheetDrawingCommand.id, params);
     });
   }
   _focusDrawingListener() {
     this.disposeWithMe(
-      this._drawingManagerService.focus$.subscribe((i) => {
-        i == null || i.length === 0 ? (this._contextService.setContextValue(we, !1), this._sheetDrawingService.focusDrawing([])) : (this._contextService.setContextValue(we, !0), this._sheetDrawingService.focusDrawing(i));
+      this._drawingManagerService.focus$.subscribe((params) => {
+        params == null || params.length === 0 ? (this._contextService.setContextValue(FOCUSING_COMMON_DRAWINGS, !1), this._sheetDrawingService.focusDrawing([])) : (this._contextService.setContextValue(FOCUSING_COMMON_DRAWINGS, !0), this._sheetDrawingService.focusDrawing(params));
       })
     );
   }
   _drawingAddListener() {
     this.disposeWithMe(
-      this._sheetDrawingService.add$.subscribe((i) => {
-        this._registerDrawing(i);
+      this._sheetDrawingService.add$.subscribe((params) => {
+        this._registerDrawing(params);
       })
     );
   }
-  _registerDrawing(i) {
-    i.forEach((n) => {
-      const t = this._sheetDrawingService.getDrawingByParam(n);
-      if (t == null)
+  _registerDrawing(params) {
+    params.forEach((param) => {
+      const drawingParam = this._sheetDrawingService.getDrawingByParam(param);
+      if (drawingParam == null)
         return;
-      const { sheetTransform: r } = t;
-      t.transform = $(r, this._selectionRenderService, this._skeletonManagerService);
+      const { sheetTransform } = drawingParam;
+      drawingParam.transform = drawingPositionToTransform(sheetTransform, this._selectionRenderService, this._skeletonManagerService);
     });
-    const e = i[0].unitId;
-    this._drawingManagerService.registerDrawingData(e, this._sheetDrawingService.getDrawingDataForUnit(e)), this._drawingManagerService.initializeNotification(e);
-  }
-};
-Ue = Ir([
-  ie(se.Rendered, Ue),
-  X(0, V),
-  X(1, he),
-  X(2, W(Zn)),
-  X(3, vt),
-  X(4, k),
-  X(5, z),
-  X(6, _t),
-  X(7, Fn),
-  X(8, W(_e)),
-  X(9, K)
-], Ue);
-var Y = function() {
-  return Y = Object.assign || function(i) {
-    for (var e, n = 1, t = arguments.length; n < t; n++) {
-      e = arguments[n];
-      for (var r in e) Object.prototype.hasOwnProperty.call(e, r) && (i[r] = e[r]);
+    const unitId = params[0].unitId;
+    this._drawingManagerService.registerDrawingData(unitId, this._sheetDrawingService.getDrawingDataForUnit(unitId)), this._drawingManagerService.initializeNotification(unitId);
+  }
+}, __name(_a2, "SheetDrawingUpdateController"), _a2);
+SheetDrawingUpdateController = __decorateClass$7([
+  __decorateParam$7(1, Inject(SheetSkeletonManagerService)),
+  __decorateParam$7(2, ICommandService),
+  __decorateParam$7(3, ISheetSelectionRenderService),
+  __decorateParam$7(4, IImageIoService),
+  __decorateParam$7(5, ISheetDrawingService),
+  __decorateParam$7(6, IDrawingManagerService),
+  __decorateParam$7(7, IContextService),
+  __decorateParam$7(8, IMessageService),
+  __decorateParam$7(9, Inject(LocaleService)),
+  __decorateParam$7(10, Inject(SheetsSelectionsService))
+], SheetDrawingUpdateController);
+var __assign = function() {
+  return __assign = Object.assign || function(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) Object.prototype.hasOwnProperty.call(s, p) && (t[p] = s[p]);
     }
-    return i;
-  }, Y.apply(this, arguments);
-}, Rr = function(i, e) {
-  var n = {};
-  for (var t in i) Object.prototype.hasOwnProperty.call(i, t) && e.indexOf(t) < 0 && (n[t] = i[t]);
-  if (i != null && typeof Object.getOwnPropertySymbols == "function")
-    for (var r = 0, t = Object.getOwnPropertySymbols(i); r < t.length; r++)
-      e.indexOf(t[r]) < 0 && Object.prototype.propertyIsEnumerable.call(i, t[r]) && (n[t[r]] = i[t[r]]);
-  return n;
-}, kt = Lt(function(i, e) {
-  var n = i.icon, t = i.id, r = i.className, s = i.extend, o = Rr(i, ["icon", "id", "className", "extend"]), a = "univerjs-icon univerjs-icon-".concat(t, " ").concat(r || "").trim(), d = Bt("_".concat(br()));
-  return Ht(n, "".concat(t), { defIds: n.defIds, idSuffix: d.current }, Y({ ref: e, className: a }, o), s);
+    return t;
+  }, __assign.apply(this, arguments);
+}, __rest = function(s, e) {
+  var t = {};
+  for (var p in s) 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++)
+      e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]) && (t[p[i]] = s[p[i]]);
+  return t;
+}, IconBase = forwardRef(function(props, ref) {
+  var icon = props.icon, id = props.id, className = props.className, extend = props.extend, restProps = __rest(props, ["icon", "id", "className", "extend"]), cls = "univerjs-icon univerjs-icon-".concat(id, " ").concat(className || "").trim(), idSuffix = useRef("_".concat(generateShortUuid()));
+  return render(icon, "".concat(id), { defIds: icon.defIds, idSuffix: idSuffix.current }, __assign({ ref, className: cls }, restProps), extend);
 });
-function Ht(i, e, n, t, r) {
-  return Wt(i.tag, Y(Y({ key: e }, Mr(i, n, r)), t), (Dr(i, n).children || []).map(function(s, o) {
-    return Ht(s, "".concat(e, "-").concat(i.tag, "-").concat(o), n, void 0, r);
+function render(node, id, runtimeProps, rootProps, extend) {
+  return createElement(node.tag, __assign(__assign({ key: id }, replaceRuntimeIdsAndExtInAttrs(node, runtimeProps, extend)), rootProps), (replaceRuntimeIdsInDefs(node, runtimeProps).children || []).map(function(child, index) {
+    return render(child, "".concat(id, "-").concat(node.tag, "-").concat(index), runtimeProps, void 0, extend);
   }));
 }
-function Mr(i, e, n) {
-  var t = Y({}, i.attrs);
-  n != null && n.colorChannel1 && t.fill === "colorChannel1" && (t.fill = n.colorChannel1);
-  var r = e.defIds;
-  return !r || r.length === 0 || (i.tag === "use" && t["xlink:href"] && (t["xlink:href"] = t["xlink:href"] + e.idSuffix), Object.entries(t).forEach(function(s) {
-    var o = s[0], a = s[1];
-    typeof a == "string" && (t[o] = a.replace(/url\(#(.*)\)/, "url(#$1".concat(e.idSuffix, ")")));
-  })), t;
+__name(render, "render");
+function replaceRuntimeIdsAndExtInAttrs(node, runtimeProps, extend) {
+  var attrs = __assign({}, node.attrs);
+  extend != null && extend.colorChannel1 && attrs.fill === "colorChannel1" && (attrs.fill = extend.colorChannel1);
+  var defIds = runtimeProps.defIds;
+  return !defIds || defIds.length === 0 || (node.tag === "use" && attrs["xlink:href"] && (attrs["xlink:href"] = attrs["xlink:href"] + runtimeProps.idSuffix), Object.entries(attrs).forEach(function(_a10) {
+    var key = _a10[0], value = _a10[1];
+    typeof value == "string" && (attrs[key] = value.replace(/url\(#(.*)\)/, "url(#$1".concat(runtimeProps.idSuffix, ")")));
+  })), attrs;
 }
-function Dr(i, e) {
-  var n, t = e.defIds;
-  return !t || t.length === 0 ? i : i.tag === "defs" && (!((n = i.children) === null || n === void 0) && n.length) ? Y(Y({}, i), { children: i.children.map(function(r) {
-    return typeof r.attrs.id == "string" && t && t.indexOf(r.attrs.id) > -1 ? Y(Y({}, r), { attrs: Y(Y({}, r.attrs), { id: r.attrs.id + e.idSuffix }) }) : r;
-  }) }) : i;
+__name(replaceRuntimeIdsAndExtInAttrs, "replaceRuntimeIdsAndExtInAttrs");
+function replaceRuntimeIdsInDefs(node, runtimeProps) {
+  var _a10, defIds = runtimeProps.defIds;
+  return !defIds || defIds.length === 0 ? node : node.tag === "defs" && (!((_a10 = node.children) === null || _a10 === void 0) && _a10.length) ? __assign(__assign({}, node), { children: node.children.map(function(child) {
+    return typeof child.attrs.id == "string" && defIds && defIds.indexOf(child.attrs.id) > -1 ? __assign(__assign({}, child), { attrs: __assign(__assign({}, child.attrs), { id: child.attrs.id + runtimeProps.idSuffix }) }) : child;
+  }) }) : node;
 }
-function br() {
+__name(replaceRuntimeIdsInDefs, "replaceRuntimeIdsInDefs");
+function generateShortUuid() {
   return Math.random().toString(36).substring(2, 8);
 }
-kt.displayName = "UniverIcon";
-var Er = { tag: "svg", attrs: { fill: "none", viewBox: "0 0 16 16", width: "1em", height: "1em" }, children: [{ tag: "path", attrs: { fill: "currentColor", d: "M2.2498 3.65005C2.2498 2.87685 2.87661 2.25005 3.64981 2.25005H7.9998C8.33118 2.25005 8.5998 1.98142 8.5998 1.65005C8.5998 1.31868 8.33118 1.05005 7.9998 1.05005H3.64981C2.21387 1.05005 1.0498 2.21411 1.0498 3.65005V12.35C1.0498 13.786 2.21386 14.95 3.6498 14.95H12.3498C13.7857 14.95 14.9498 13.786 14.9498 12.3501V8.00005C14.9498 7.66868 14.6812 7.40005 14.3498 7.40005C14.0184 7.40005 13.7498 7.66868 13.7498 8.00005V9.23974L12.2385 8.1063C11.7252 7.72129 11.0068 7.7723 10.5531 8.22605L9.00869 9.77041L6.73916 7.8251C6.24387 7.40055 5.5095 7.41278 5.02864 7.85359L2.2498 10.4009V3.65005ZM2.2498 12.0287V12.35C2.2498 13.1232 2.87661 13.75 3.6498 13.75H12.3498C13.123 13.75 13.7498 13.1232 13.7498 12.3501V10.7397L11.5186 9.06631C11.4829 9.03956 11.433 9.04314 11.4016 9.07458L9.92249 10.5537L11.1015 11.5642C11.3531 11.7799 11.3822 12.1587 11.1666 12.4103C10.9509 12.6619 10.5721 12.691 10.3205 12.4753L5.9582 8.7362C5.92384 8.70674 5.87288 8.70758 5.83952 8.73816L2.2498 12.0287Z", fillRule: "evenodd", clipRule: "evenodd" } }, { tag: "path", attrs: { fill: "currentColor", d: "M11.8097 1.14783C12.1411 1.14783 12.4097 1.41646 12.4097 1.74783V3.297H14.1541C14.4855 3.297 14.7541 3.56563 14.7541 3.897C14.7541 4.22837 14.4855 4.497 14.1541 4.497H12.4097V6.24167C12.4097 6.57304 12.1411 6.84167 11.8097 6.84167C11.4783 6.84167 11.2097 6.57304 11.2097 6.24167V4.497H9.6603C9.32893 4.497 9.0603 4.22837 9.0603 3.897C9.0603 3.56563 9.32893 3.297 9.6603 3.297H11.2097V1.74783C11.2097 1.41646 11.4783 1.14783 11.8097 1.14783Z" } }] }, Xt = Lt(function(i, e) {
-  return Wt(kt, Object.assign({}, i, {
+__name(generateShortUuid, "generateShortUuid");
+IconBase.displayName = "UniverIcon";
+var element = { tag: "svg", attrs: { fill: "none", viewBox: "0 0 16 16", width: "1em", height: "1em" }, children: [{ tag: "path", attrs: { fill: "currentColor", d: "M2.2498 3.65005C2.2498 2.87685 2.87661 2.25005 3.64981 2.25005H7.9998C8.33118 2.25005 8.5998 1.98142 8.5998 1.65005C8.5998 1.31868 8.33118 1.05005 7.9998 1.05005H3.64981C2.21387 1.05005 1.0498 2.21411 1.0498 3.65005V12.35C1.0498 13.786 2.21386 14.95 3.6498 14.95H12.3498C13.7857 14.95 14.9498 13.786 14.9498 12.3501V8.00005C14.9498 7.66868 14.6812 7.40005 14.3498 7.40005C14.0184 7.40005 13.7498 7.66868 13.7498 8.00005V9.23974L12.2385 8.1063C11.7252 7.72129 11.0068 7.7723 10.5531 8.22605L9.00869 9.77041L6.73916 7.8251C6.24387 7.40055 5.5095 7.41278 5.02864 7.85359L2.2498 10.4009V3.65005ZM2.2498 12.0287V12.35C2.2498 13.1232 2.87661 13.75 3.6498 13.75H12.3498C13.123 13.75 13.7498 13.1232 13.7498 12.3501V10.7397L11.5186 9.06631C11.4829 9.03956 11.433 9.04314 11.4016 9.07458L9.92249 10.5537L11.1015 11.5642C11.3531 11.7799 11.3822 12.1587 11.1666 12.4103C10.9509 12.6619 10.5721 12.691 10.3205 12.4753L5.9582 8.7362C5.92384 8.70674 5.87288 8.70758 5.83952 8.73816L2.2498 12.0287Z", fillRule: "evenodd", clipRule: "evenodd" } }, { tag: "path", attrs: { fill: "currentColor", d: "M11.8097 1.14783C12.1411 1.14783 12.4097 1.41646 12.4097 1.74783V3.297H14.1541C14.4855 3.297 14.7541 3.56563 14.7541 3.897C14.7541 4.22837 14.4855 4.497 14.1541 4.497H12.4097V6.24167C12.4097 6.57304 12.1411 6.84167 11.8097 6.84167C11.4783 6.84167 11.2097 6.57304 11.2097 6.24167V4.497H9.6603C9.32893 4.497 9.0603 4.22837 9.0603 3.897C9.0603 3.56563 9.32893 3.297 9.6603 3.297H11.2097V1.74783C11.2097 1.41646 11.4783 1.14783 11.8097 1.14783Z" } }] }, AddImageSingle = forwardRef(function(props, ref) {
+  return createElement(IconBase, Object.assign({}, props, {
     id: "add-image-single",
-    ref: e,
-    icon: Er
+    ref,
+    icon: element
   }));
 });
-Xt.displayName = "AddImageSingle";
-const yr = "univer-upload-file-menu", Or = "univer-upload-file-menu-input", wt = {
-  uploadFileMenu: yr,
-  uploadFileMenuInput: Or
-}, zt = "COMPONENT_UPLOAD_FILE_MENU";
-var We = /* @__PURE__ */ ((i) => (i[i.cellImage = 0] = "cellImage", i[i.floatImage = 1] = "floatImage", i))(We || {});
-const Pr = (i) => {
-  const { type: e } = i, n = ee(V), t = Bt(null), r = () => {
-    var a;
-    (a = t.current) == null || a.click();
-  }, s = Rn.map((a) => `.${a.replace("image/", "")}`).join(","), o = (a) => {
-    const d = a.target.files;
-    if (d == null)
+AddImageSingle.displayName = "AddImageSingle";
+const uploadFileMenu = "univer-upload-file-menu", uploadFileMenuInput = "univer-upload-file-menu-input", styles$1 = {
+  uploadFileMenu,
+  uploadFileMenuInput
+}, COMPONENT_UPLOAD_FILE_MENU = "COMPONENT_UPLOAD_FILE_MENU";
+var UploadFileType = /* @__PURE__ */ ((UploadFileType2) => (UploadFileType2[UploadFileType2.cellImage = 0] = "cellImage", UploadFileType2[UploadFileType2.floatImage = 1] = "floatImage", UploadFileType2))(UploadFileType || {});
+const UploadFileMenu = /* @__PURE__ */ __name((props) => {
+  const { type } = props, commandService = useDependency(ICommandService), fileInputRef = useRef(null), handleButtonClick = /* @__PURE__ */ __name(() => {
+    var _a10;
+    (_a10 = fileInputRef.current) == null || _a10.click();
+  }, "handleButtonClick"), imageAccept = DRAWING_IMAGE_ALLOW_IMAGE_LIST.map((image) => `.${image.replace("image/", "")}`).join(","), handleFileChange = /* @__PURE__ */ __name((event) => {
+    const fileList = event.target.files;
+    if (fileList == null)
       return;
-    const h = Array.from(d);
-    e === We.floatImage ? n.executeCommand(xe.id, { files: h }) : e === We.cellImage && n.executeCommand(Be.id, { files: h }), t.current && (t.current.value = "");
-  };
-  return /* @__PURE__ */ L.createElement("div", { onClick: r, className: wt.uploadFileMenu }, /* @__PURE__ */ L.createElement(
+    const files = Array.from(fileList);
+    type === UploadFileType.floatImage ? commandService.executeCommand(InsertFloatImageOperation.id, { files }) : type === UploadFileType.cellImage && commandService.executeCommand(InsertCellImageOperation.id, { files }), fileInputRef.current && (fileInputRef.current.value = "");
+  }, "handleFileChange");
+  return /* @__PURE__ */ React.createElement("div", { onClick: handleButtonClick, className: styles$1.uploadFileMenu }, /* @__PURE__ */ React.createElement(
     "input",
     {
       type: "file",
-      className: wt.uploadFileMenuInput,
-      ref: t,
-      onChange: o,
-      accept: s,
+      className: styles$1.uploadFileMenuInput,
+      ref: fileInputRef,
+      onChange: handleFileChange,
+      accept: imageAccept,
       multiple: !0
     }
   ));
-}, Kt = "addition-and-subtraction-single", Jt = "sheet.menu.image";
-function Tr(i) {
+}, "UploadFileMenu"), IMAGE_UPLOAD_ICON = "addition-and-subtraction-single", IMAGE_MENU_ID = "sheet.menu.image";
+function ImageMenuFactory(accessor) {
   return {
-    id: Jt,
-    type: St.SUBITEMS,
-    positions: [Yn.TOOLBAR_START],
-    group: kn.TOOLBAR_FORMULAS_INSERT,
-    icon: Kt,
+    id: IMAGE_MENU_ID,
+    type: MenuItemType.SUBITEMS,
+    positions: [MenuPosition.TOOLBAR_START],
+    group: MenuGroup.TOOLBAR_FORMULAS_INSERT,
+    icon: IMAGE_UPLOAD_ICON,
     tooltip: "sheetImage.title",
-    hidden$: Ct(i, B.UNIVER_SHEET),
-    disabled$: An(i, { workbookTypes: [Ze], worksheetTypes: [Pe], rangeTypes: [qn] })
+    hidden$: getMenuHiddenObservable(accessor, UniverInstanceType.UNIVER_SHEET),
+    disabled$: getCurrentRangeDisable$(accessor, { workbookTypes: [WorkbookEditablePermission], worksheetTypes: [WorksheetEditPermission], rangeTypes: [RangeProtectionPermissionEditPoint] })
   };
 }
-function Ur(i) {
+__name(ImageMenuFactory, "ImageMenuFactory");
+function UploadFloatImageMenuFactory(_accessor) {
   return {
-    id: xe.id,
+    id: InsertFloatImageOperation.id,
     title: "sheetImage.upload.float",
-    type: St.SELECTOR,
+    type: MenuItemType.SELECTOR,
     label: {
-      name: zt,
+      name: COMPONENT_UPLOAD_FILE_MENU,
       props: {
-        type: We.floatImage
+        type: UploadFileType.floatImage
       }
     },
-    positions: [Jt],
-    hidden$: Ct(i, B.UNIVER_SHEET)
+    positions: [IMAGE_MENU_ID],
+    hidden$: getMenuHiddenObservable(_accessor, UniverInstanceType.UNIVER_SHEET)
   };
 }
-const Ar = "univer-image-common-panel", Nr = "univer-image-common-panel-grid", jr = "univer-image-common-panel-border", Lr = "univer-image-common-panel-title", Br = "univer-image-common-panel-subtitle", Wr = "univer-image-common-panel-row", $r = "univer-image-common-panel-row-vertical", Vr = "univer-image-common-panel-column", Gr = "univer-image-common-panel-column-center", xr = "univer-image-common-panel-inline", Fr = "univer-image-common-panel-span2", Yr = "univer-image-common-panel-span3", kr = "univer-image-common-panel-input", Hr = "univer-sheet-image-menu", Xr = "univer-sheet-image-menu-input", Z = {
-  imageCommonPanel: Ar,
-  imageCommonPanelGrid: Nr,
-  imageCommonPanelBorder: jr,
-  imageCommonPanelTitle: Lr,
-  imageCommonPanelSubtitle: Br,
-  imageCommonPanelRow: Wr,
-  imageCommonPanelRowVertical: $r,
-  imageCommonPanelColumn: Vr,
-  imageCommonPanelColumnCenter: Gr,
-  imageCommonPanelInline: xr,
-  imageCommonPanelSpan2: Fr,
-  imageCommonPanelSpan3: Yr,
-  imageCommonPanelInput: kr,
-  sheetImageMenu: Hr,
-  sheetImageMenuInput: Xr
-}, zr = (i) => {
-  var v;
-  const e = ee(V), n = ee(_e), t = ee(z), r = ee(K), { drawings: s } = i, o = s[0];
-  if (o == null)
+__name(UploadFloatImageMenuFactory, "UploadFloatImageMenuFactory");
+const imageCommonPanel = "univer-image-common-panel", imageCommonPanelGrid = "univer-image-common-panel-grid", imageCommonPanelBorder = "univer-image-common-panel-border", imageCommonPanelTitle = "univer-image-common-panel-title", imageCommonPanelSubtitle = "univer-image-common-panel-subtitle", imageCommonPanelRow = "univer-image-common-panel-row", imageCommonPanelRowVertical = "univer-image-common-panel-row-vertical", imageCommonPanelColumn = "univer-image-common-panel-column", imageCommonPanelColumnCenter = "univer-image-common-panel-column-center", imageCommonPanelInline = "univer-image-common-panel-inline", imageCommonPanelSpan2 = "univer-image-common-panel-span2", imageCommonPanelSpan3 = "univer-image-common-panel-span3", imageCommonPanelInput = "univer-image-common-panel-input", sheetImageMenu = "univer-sheet-image-menu", sheetImageMenuInput = "univer-sheet-image-menu-input", styles = {
+  imageCommonPanel,
+  imageCommonPanelGrid,
+  imageCommonPanelBorder,
+  imageCommonPanelTitle,
+  imageCommonPanelSubtitle,
+  imageCommonPanelRow,
+  imageCommonPanelRowVertical,
+  imageCommonPanelColumn,
+  imageCommonPanelColumnCenter,
+  imageCommonPanelInline,
+  imageCommonPanelSpan2,
+  imageCommonPanelSpan3,
+  imageCommonPanelInput,
+  sheetImageMenu,
+  sheetImageMenuInput
+}, SheetDrawingAnchor = /* @__PURE__ */ __name((props) => {
+  var _a10;
+  const commandService = useDependency(ICommandService), localeService = useDependency(LocaleService), drawingManagerService = useDependency(IDrawingManagerService), renderManagerService = useDependency(IRenderManagerService), { drawings } = props, drawingParam = drawings[0];
+  if (drawingParam == null)
     return;
-  const { unitId: a } = o, d = r.getRenderById(a), h = d == null ? void 0 : d.scene;
-  if (h == null)
+  const { unitId } = drawingParam, renderObject = renderManagerService.getRenderById(unitId), scene = renderObject == null ? void 0 : renderObject.scene;
+  if (scene == null)
     return;
-  const l = h.getTransformerByCreate(), [c, u] = et(!0), g = (v = o.anchorType) != null ? v : O.Position, [f, m] = et(g);
-  function p(R, _) {
-    const b = [];
-    return R.forEach((w) => {
-      const { oKey: P } = w, D = _.getDrawingOKey(P);
-      if (D == null)
-        return b.push(null), !0;
-      const { unitId: T, subUnitId: U, drawingId: M, drawingType: I, anchorType: A, sheetTransform: G } = D;
-      b.push({
-        unitId: T,
-        subUnitId: U,
-        drawingId: M,
-        anchorType: A,
-        sheetTransform: G,
-        drawingType: I
+  const transformer = scene.getTransformerByCreate(), [anchorShow, setAnchorShow] = useState(!0), type = (_a10 = drawingParam.anchorType) != null ? _a10 : SheetDrawingAnchorType.Position, [value, setValue] = useState(type);
+  function getUpdateParams(objects, drawingManagerService2) {
+    const params = [];
+    return objects.forEach((object) => {
+      const { oKey } = object, searchParam = drawingManagerService2.getDrawingOKey(oKey);
+      if (searchParam == null)
+        return params.push(null), !0;
+      const { unitId: unitId2, subUnitId, drawingId, drawingType, anchorType, sheetTransform } = searchParam;
+      params.push({
+        unitId: unitId2,
+        subUnitId,
+        drawingId,
+        anchorType,
+        sheetTransform,
+        drawingType
       });
-    }), b;
-  }
-  rt(() => {
-    const R = l.clearControl$.subscribe((b) => {
-      b === !0 && u(!1);
-    }), _ = l.changeStart$.subscribe((b) => {
-      var D;
-      const { objects: w } = b, P = p(w, t);
-      if (P.length === 0)
-        u(!1);
-      else if (P.length >= 1) {
-        u(!0);
-        const T = ((D = P[0]) == null ? void 0 : D.anchorType) || O.Position;
-        m(T);
+    }), params;
+  }
+  __name(getUpdateParams, "getUpdateParams"), useEffect(() => {
+    const onClearControlObserver = transformer.clearControl$.subscribe((changeSelf) => {
+      changeSelf === !0 && setAnchorShow(!1);
+    }), onChangeStartObserver = transformer.changeStart$.subscribe((state) => {
+      var _a11;
+      const { objects } = state, params = getUpdateParams(objects, drawingManagerService);
+      if (params.length === 0)
+        setAnchorShow(!1);
+      else if (params.length >= 1) {
+        setAnchorShow(!0);
+        const anchorType = ((_a11 = params[0]) == null ? void 0 : _a11.anchorType) || SheetDrawingAnchorType.Position;
+        setValue(anchorType);
       }
     });
     return () => {
-      _.unsubscribe(), R.unsubscribe();
+      onChangeStartObserver.unsubscribe(), onClearControlObserver.unsubscribe();
     };
   }, []);
-  function S(R) {
-    m(R);
-    const _ = t.getFocusDrawings();
-    if (_.length === 0)
+  function handleChange(value2) {
+    setValue(value2);
+    const focusDrawings = drawingManagerService.getFocusDrawings();
+    if (focusDrawings.length === 0)
       return;
-    const b = _.map((w) => ({
-      unitId: w.unitId,
-      subUnitId: w.subUnitId,
-      drawingId: w.drawingId,
-      anchorType: R
+    const updateParams = focusDrawings.map((drawing) => ({
+      unitId: drawing.unitId,
+      subUnitId: drawing.subUnitId,
+      drawingId: drawing.drawingId,
+      anchorType: value2
     }));
-    e.executeCommand(Fe.id, {
-      unitId: _[0].unitId,
-      drawings: b
+    commandService.executeCommand(SetSheetDrawingCommand.id, {
+      unitId: focusDrawings[0].unitId,
+      drawings: updateParams
     });
   }
-  const C = (R) => R ? "block" : "none";
-  return /* @__PURE__ */ L.createElement("div", { className: Ee(Z.imageCommonPanelGrid, Z.imageCommonPanelBorder), style: { display: C(c) } }, /* @__PURE__ */ L.createElement("div", { className: Z.imageCommonPanelRow }, /* @__PURE__ */ L.createElement("div", { className: Ee(Z.imageCommonPanelColumn, Z.imageCommonPanelTitle) }, /* @__PURE__ */ L.createElement("div", null, n.t("drawing-anchor.title")))), /* @__PURE__ */ L.createElement("div", { className: Ee(Z.imageCommonPanelRow) }, /* @__PURE__ */ L.createElement("div", { className: Ee(Z.imageCommonPanelColumn) }, /* @__PURE__ */ L.createElement(cr, { value: f, onChange: S, direction: "vertical" }, /* @__PURE__ */ L.createElement(Xe, { value: O.Both }, n.t("drawing-anchor.both")), /* @__PURE__ */ L.createElement(Xe, { value: O.Position }, n.t("drawing-anchor.position")), /* @__PURE__ */ L.createElement(Xe, { value: O.None }, n.t("drawing-anchor.none"))))));
-}, Kr = () => {
-  const i = ee(z), e = i.getFocusDrawings(), [n, t] = et(e);
-  return rt(() => {
-    const r = i.focus$.subscribe((s) => {
-      t(s);
+  __name(handleChange, "handleChange");
+  const gridDisplay = /* @__PURE__ */ __name((isShow) => isShow ? "block" : "none", "gridDisplay");
+  return /* @__PURE__ */ React.createElement("div", { className: clsx(styles.imageCommonPanelGrid, styles.imageCommonPanelBorder), style: { display: gridDisplay(anchorShow) } }, /* @__PURE__ */ React.createElement("div", { className: styles.imageCommonPanelRow }, /* @__PURE__ */ React.createElement("div", { className: clsx(styles.imageCommonPanelColumn, styles.imageCommonPanelTitle) }, /* @__PURE__ */ React.createElement("div", null, localeService.t("drawing-anchor.title")))), /* @__PURE__ */ React.createElement("div", { className: clsx(styles.imageCommonPanelRow) }, /* @__PURE__ */ React.createElement("div", { className: clsx(styles.imageCommonPanelColumn) }, /* @__PURE__ */ React.createElement(RadioGroup, { value, onChange: handleChange, direction: "vertical" }, /* @__PURE__ */ React.createElement(Radio, { value: SheetDrawingAnchorType.Both }, localeService.t("drawing-anchor.both")), /* @__PURE__ */ React.createElement(Radio, { value: SheetDrawingAnchorType.Position }, localeService.t("drawing-anchor.position")), /* @__PURE__ */ React.createElement(Radio, { value: SheetDrawingAnchorType.None }, localeService.t("drawing-anchor.none"))))));
+}, "SheetDrawingAnchor"), SheetDrawingPanel = /* @__PURE__ */ __name(() => {
+  const drawingManagerService = useDependency(IDrawingManagerService), focusDrawings = drawingManagerService.getFocusDrawings(), [drawings, setDrawings] = useState(focusDrawings);
+  return useEffect(() => {
+    const focusDispose = drawingManagerService.focus$.subscribe((drawings2) => {
+      setDrawings(drawings2);
     });
     return () => {
-      r.unsubscribe();
+      focusDispose.unsubscribe();
     };
-  }, []), !!(n != null && n.length) && /* @__PURE__ */ L.createElement("div", { className: Z.imageCommonPanel }, /* @__PURE__ */ L.createElement(wn, { drawings: n }), /* @__PURE__ */ L.createElement(zr, { drawings: n }));
-}, ve = {
+  }, []), !!(drawings != null && drawings.length) && /* @__PURE__ */ React.createElement("div", { className: styles.imageCommonPanel }, /* @__PURE__ */ React.createElement(DrawingCommonPanel, { drawings }), /* @__PURE__ */ React.createElement(SheetDrawingAnchor, { drawings }));
+}, "SheetDrawingPanel"), MoveDrawingsCommand = {
   id: "sheet.command.move-drawing",
-  type: F.COMMAND,
-  handler: (i, e) => {
-    const n = i.get(V), t = i.get(k), r = i.get(Ge), { direction: s } = e, o = t.getFocusDrawings();
-    if (o.length === 0)
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor, params) => {
+    const commandService = accessor.get(ICommandService), drawingManagerService = accessor.get(ISheetDrawingService), selectionRenderService = accessor.get(ISheetSelectionRenderService), { direction } = params, drawings = drawingManagerService.getFocusDrawings();
+    if (drawings.length === 0)
       return !1;
-    const a = o[0].unitId, d = o.map((l) => {
-      const { transform: c } = l;
-      if (c == null)
+    const unitId = drawings[0].unitId, newDrawings = drawings.map((drawing) => {
+      const { transform } = drawing;
+      if (transform == null)
         return null;
-      const u = { ...c }, { left: g = 0, top: f = 0 } = c;
-      return s === q.UP ? u.top = f - 1 : s === q.DOWN ? u.top = f + 1 : s === q.LEFT ? u.left = g - 1 : s === q.RIGHT && (u.left = g + 1), {
-        ...l,
-        transform: u,
-        sheetTransform: N(u, r)
+      const newTransform = { ...transform }, { left = 0, top = 0 } = transform;
+      return direction === Direction.UP ? newTransform.top = top - 1 : direction === Direction.DOWN ? newTransform.top = top + 1 : direction === Direction.LEFT ? newTransform.left = left - 1 : direction === Direction.RIGHT && (newTransform.left = left + 1), {
+        ...drawing,
+        transform: newTransform,
+        sheetTransform: transformToDrawingPosition(newTransform, selectionRenderService)
       };
-    }).filter((l) => l != null);
-    return n.syncExecuteCommand(Fe.id, {
-      unitId: a,
-      drawings: d
-    }) ? (n.syncExecuteCommand(j.id, [a]), !0) : !1;
-  }
-}, Zt = {
+    }).filter((drawing) => drawing != null);
+    return commandService.syncExecuteCommand(SetSheetDrawingCommand.id, {
+      unitId,
+      drawings: newDrawings
+    }) ? (commandService.syncExecuteCommand(ClearSheetDrawingTransformerOperation.id, [unitId]), !0) : !1;
+  }, "handler")
+}, DeleteDrawingsCommand = {
   id: "sheet.command.delete-drawing",
-  type: F.COMMAND,
-  handler: (i) => {
-    const e = i.get(V), t = i.get(k).getFocusDrawings();
-    if (t.length === 0)
+  type: CommandType.COMMAND,
+  handler: /* @__PURE__ */ __name((accessor) => {
+    const commandService = accessor.get(ICommandService), drawings = accessor.get(ISheetDrawingService).getFocusDrawings();
+    if (drawings.length === 0)
       return !1;
-    const r = t[0].unitId, s = t.map((o) => {
-      const { unitId: a, subUnitId: d, drawingId: h, drawingType: l } = o;
+    const unitId = drawings[0].unitId, newDrawings = drawings.map((drawing) => {
+      const { unitId: unitId2, subUnitId, drawingId, drawingType } = drawing;
       return {
-        unitId: a,
-        subUnitId: d,
-        drawingId: h,
-        drawingType: l
+        unitId: unitId2,
+        subUnitId,
+        drawingId,
+        drawingType
       };
     });
-    return e.executeCommand(it.id, {
-      unitId: r,
-      drawings: s
+    return commandService.executeCommand(RemoveSheetDrawingCommand.id, {
+      unitId,
+      drawings: newDrawings
     });
-  }
+  }, "handler")
 };
-function Se(i) {
-  return !i.getContextValue(sn) && !i.getContextValue(on) && i.getContextValue(we);
+function whenSheetDrawingFocused(contextService) {
+  return !contextService.getContextValue(FOCUSING_FORMULA_EDITOR) && !contextService.getContextValue(EDITOR_ACTIVATED) && contextService.getContextValue(FOCUSING_COMMON_DRAWINGS);
 }
-const Jr = {
-  id: ve.id,
+__name(whenSheetDrawingFocused, "whenSheetDrawingFocused");
+const MoveDrawingDownShortcutItem = {
+  id: MoveDrawingsCommand.id,
   description: "shortcut.sheet.drawing-move-down",
   group: "4_sheet-drawing-view",
-  binding: ue.ARROW_DOWN,
+  binding: KeyCode.ARROW_DOWN,
   priority: 100,
-  preconditions: Se,
+  preconditions: whenSheetDrawingFocused,
   staticParameters: {
-    direction: q.DOWN
+    direction: Direction.DOWN
   }
-}, Zr = {
-  id: ve.id,
+}, MoveDrawingUpShortcutItem = {
+  id: MoveDrawingsCommand.id,
   description: "shortcut.sheet.drawing-move-up",
   group: "4_sheet-drawing-view",
-  binding: ue.ARROW_UP,
+  binding: KeyCode.ARROW_UP,
   priority: 100,
-  preconditions: Se,
+  preconditions: whenSheetDrawingFocused,
   staticParameters: {
-    direction: q.UP
+    direction: Direction.UP
   }
-}, qr = {
-  id: ve.id,
+}, MoveDrawingLeftShortcutItem = {
+  id: MoveDrawingsCommand.id,
   description: "shortcut.sheet.drawing-move-left",
   group: "4_sheet-drawing-view",
-  binding: ue.ARROW_LEFT,
+  binding: KeyCode.ARROW_LEFT,
   priority: 100,
-  preconditions: Se,
+  preconditions: whenSheetDrawingFocused,
   staticParameters: {
-    direction: q.LEFT
+    direction: Direction.LEFT
   }
-}, Qr = {
-  id: ve.id,
+}, MoveDrawingRightShortcutItem = {
+  id: MoveDrawingsCommand.id,
   description: "shortcut.sheet.drawing-move-right",
   group: "4_sheet-drawing-view",
-  binding: ue.ARROW_RIGHT,
+  binding: KeyCode.ARROW_RIGHT,
   priority: 100,
-  preconditions: Se,
+  preconditions: whenSheetDrawingFocused,
   staticParameters: {
-    direction: q.RIGHT
+    direction: Direction.RIGHT
   }
-}, ei = {
-  id: Zt.id,
+}, DeleteDrawingsShortcutItem = {
+  id: DeleteDrawingsCommand.id,
   description: "shortcut.sheet.drawing-delete",
   group: "4_sheet-drawing-view",
   // when focusing on any other input tag do not trigger this shortcut
-  preconditions: Se,
-  binding: ue.DELETE,
-  mac: ue.BACKSPACE
+  preconditions: whenSheetDrawingFocused,
+  binding: KeyCode.DELETE,
+  mac: KeyCode.BACKSPACE
 };
-var ti = Object.defineProperty, ni = Object.getOwnPropertyDescriptor, ri = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? ni(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && ti(e, n, r), r;
-}, me = (i, e) => (n, t) => e(n, t, i);
-const ii = {};
-let pe = class extends oe {
-  constructor(i, e, n, t, r, s) {
-    super(), this._config = i, this._injector = e, this._componentManager = n, this._menuService = t, this._commandService = r, this._shortcutService = s, this._init();
+var __defProp$6 = Object.defineProperty, __getOwnPropDesc$6 = Object.getOwnPropertyDescriptor, __decorateClass$6 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$6(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$6(target, key, result), result;
+}, "__decorateClass$6"), __decorateParam$6 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$6");
+const DefaultSheetsDrawingConfig = {};
+var _a3;
+let SheetDrawingUIController = (_a3 = class extends Disposable {
+  constructor(_config, _injector, _componentManager, _menuService, _commandService, _shortcutService) {
+    super(), this._config = _config, this._injector = _injector, this._componentManager = _componentManager, this._menuService = _menuService, this._commandService = _commandService, this._shortcutService = _shortcutService, this._init();
   }
   _initCustomComponents() {
-    const i = this._componentManager;
-    this.disposeWithMe(i.register(Kt, Xt)), this.disposeWithMe(i.register(zt, Pr)), this.disposeWithMe(i.register($t, Kr));
+    const componentManager = this._componentManager;
+    this.disposeWithMe(componentManager.register(IMAGE_UPLOAD_ICON, AddImageSingle)), this.disposeWithMe(componentManager.register(COMPONENT_UPLOAD_FILE_MENU, UploadFileMenu)), this.disposeWithMe(componentManager.register(COMPONENT_SHEET_DRAWING_PANEL, SheetDrawingPanel));
   }
   _initMenus() {
-    const { menu: i = {} } = this._config;
+    const { menu = {} } = this._config;
     [
-      Tr,
-      Ur
+      ImageMenuFactory,
+      UploadFloatImageMenuFactory
       // UploadCellImageMenuFactory,
-    ].forEach((e) => {
-      this._menuService.addMenuItem(e(this._injector), i);
+    ].forEach((menuFactory) => {
+      this._menuService.addMenuItem(menuFactory(this._injector), menu);
     });
   }
   _initCommands() {
     [
-      xe,
-      Be,
-      st,
-      it,
-      Fe,
-      Vt,
-      j,
-      Gt,
-      Ft,
-      Yt,
-      ve,
-      Zt,
-      xt
-    ].forEach((i) => this.disposeWithMe(this._commandService.registerCommand(i)));
+      InsertFloatImageOperation,
+      InsertCellImageOperation,
+      InsertSheetDrawingCommand,
+      RemoveSheetDrawingCommand,
+      SetSheetDrawingCommand,
+      SidebarSheetDrawingOperation,
+      ClearSheetDrawingTransformerOperation,
+      EditSheetDrawingOperation,
+      GroupSheetDrawingCommand,
+      UngroupSheetDrawingCommand,
+      MoveDrawingsCommand,
+      DeleteDrawingsCommand,
+      SetDrawingArrangeCommand
+    ].forEach((command) => this.disposeWithMe(this._commandService.registerCommand(command)));
   }
   _initShortcuts() {
     [
       // sheet drawing shortcuts
-      Jr,
-      Zr,
-      qr,
-      Qr,
-      ei
-    ].forEach((i) => {
-      this.disposeWithMe(this._shortcutService.registerShortcut(i));
+      MoveDrawingDownShortcutItem,
+      MoveDrawingUpShortcutItem,
+      MoveDrawingLeftShortcutItem,
+      MoveDrawingRightShortcutItem,
+      DeleteDrawingsShortcutItem
+    ].forEach((item) => {
+      this.disposeWithMe(this._shortcutService.registerShortcut(item));
     });
   }
   _init() {
     this._initCommands(), this._initCustomComponents(), this._initMenus(), this._initShortcuts();
   }
-};
-pe = ri([
-  ie(se.Rendered, pe),
-  me(1, W(nt)),
-  me(2, W(Hn)),
-  me(3, Xn),
-  me(4, V),
-  me(5, zn)
-], pe);
-var si = Object.defineProperty, oi = Object.getOwnPropertyDescriptor, ai = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? oi(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && si(e, n, r), r;
-}, ce = (i, e) => (n, t) => e(n, t, i);
-const ci = [
-  It.id,
-  Rt.id,
-  Mt.id,
-  Dt.id,
-  bt.id,
-  Et.id,
-  yt.id,
-  Ot.id,
-  qe.id,
-  Qe.id,
-  Pt.id,
-  Tt.id,
-  Ut.id,
-  At.id,
-  Nt.id,
-  jt.id
-], di = [
-  Qn.id,
-  er.id,
-  tr.id,
-  nr.id,
-  rr.id,
-  ir.id
+}, __name(_a3, "SheetDrawingUIController"), _a3);
+SheetDrawingUIController = __decorateClass$6([
+  OnLifecycle(LifecycleStages.Rendered, SheetDrawingUIController),
+  __decorateParam$6(1, Inject(Injector)),
+  __decorateParam$6(2, Inject(ComponentManager)),
+  __decorateParam$6(3, IMenuService),
+  __decorateParam$6(4, ICommandService),
+  __decorateParam$6(5, IShortcutService)
+], SheetDrawingUIController);
+var __defProp$5 = Object.defineProperty, __getOwnPropDesc$5 = Object.getOwnPropertyDescriptor, __decorateClass$5 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$5(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$5(target, key, result), result;
+}, "__decorateClass$5"), __decorateParam$5 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$5");
+const UPDATE_COMMANDS = [
+  InsertRowCommand.id,
+  InsertColCommand.id,
+  RemoveRowCommand.id,
+  RemoveColCommand.id,
+  DeleteRangeMoveLeftCommand.id,
+  DeleteRangeMoveUpCommand.id,
+  InsertRangeMoveDownCommand.id,
+  InsertRangeMoveRightCommand.id,
+  DeltaRowHeightCommand.id,
+  SetRowHeightCommand.id,
+  DeltaColumnWidthCommand.id,
+  SetColWidthCommand.id,
+  SetRowHiddenCommand.id,
+  SetSpecificRowsVisibleCommand.id,
+  SetSpecificColsVisibleCommand.id,
+  SetColHiddenCommand.id
+], REFRESH_MUTATIONS = [
+  SetRowVisibleMutation.id,
+  SetRowHiddenMutation.id,
+  SetColVisibleMutation.id,
+  SetColHiddenMutation.id,
+  SetWorksheetRowHeightMutation.id,
+  SetWorksheetColWidthMutation.id
 ];
-let Ae = class extends oe {
-  constructor(i, e, n, t, r, s) {
-    super(), this._commandService = i, this._sheetInterceptorService = e, this._renderManagerService = n, this._sheetDrawingService = t, this._drawingManagerService = r, this._univerInstanceService = s, this._init();
-  }
-  // TODO@wzhudev: selection render service would be a render unit, we we cannot
-  // easily access it here.
-  get _selectionRenderService() {
-    return this._renderManagerService.getRenderById(
-      this._univerInstanceService.getCurrentUnitForType(B.UNIVER_SHEET).getUnitId()
-    ).with(Ge);
-  }
-  get _skeletonManagerService() {
-    return this._renderManagerService.getRenderById(
-      this._univerInstanceService.getCurrentUnitForType(B.UNIVER_SHEET).getUnitId()
-    ).with(re);
-  }
-  _init() {
-    this._sheetInterceptorListener(), this._commandListener(), this._sheetRefreshListener();
+var _a4;
+let SheetDrawingTransformAffectedController = (_a4 = class extends Disposable {
+  constructor(_context, _commandService, _selectionRenderService, _skeletonManagerService, _sheetInterceptorService, _sheetDrawingService, _drawingManagerService, _univerInstanceService) {
+    super(), this._context = _context, this._commandService = _commandService, this._selectionRenderService = _selectionRenderService, this._skeletonManagerService = _skeletonManagerService, this._sheetInterceptorService = _sheetInterceptorService, this._sheetDrawingService = _sheetDrawingService, this._drawingManagerService = _drawingManagerService, this._univerInstanceService = _univerInstanceService, this._sheetInterceptorListener(), this._commandListener(), this._sheetRefreshListener();
   }
   _sheetInterceptorListener() {
     this.disposeWithMe(
       this._sheetInterceptorService.interceptCommand({
-        getMutations: (i) => {
-          if (!ci.includes(i.id))
+        getMutations: /* @__PURE__ */ __name((commandInfo) => {
+          if (!UPDATE_COMMANDS.includes(commandInfo.id))
             return { redos: [], undos: [] };
-          if (i.params == null)
+          if (commandInfo.params == null)
             return { redos: [], undos: [] };
-          const e = i.id;
-          if (e === It.id)
-            return this._moveRowInterceptor(i.params, "insert");
-          if (e === Rt.id)
-            return this._moveColInterceptor(i.params, "insert");
-          if (e === Mt.id)
-            return this._moveRowInterceptor(i.params, "remove");
-          if (e === Dt.id)
-            return this._moveColInterceptor(i.params, "remove");
-          if (e === bt.id) {
-            const { range: n } = i.params;
+          const cId = commandInfo.id;
+          if (cId === InsertRowCommand.id)
+            return this._moveRowInterceptor(commandInfo.params, "insert");
+          if (cId === InsertColCommand.id)
+            return this._moveColInterceptor(commandInfo.params, "insert");
+          if (cId === RemoveRowCommand.id)
+            return this._moveRowInterceptor(commandInfo.params, "remove");
+          if (cId === RemoveColCommand.id)
+            return this._moveColInterceptor(commandInfo.params, "remove");
+          if (cId === DeleteRangeMoveLeftCommand.id) {
+            const { range } = commandInfo.params;
             return this._getRangeMoveUndo(
-              n,
+              range,
               0
               /* deleteLeft */
             );
-          } else if (e === Et.id) {
-            const { range: n } = i.params;
+          } else if (cId === DeleteRangeMoveUpCommand.id) {
+            const { range } = commandInfo.params;
             return this._getRangeMoveUndo(
-              n,
+              range,
               1
               /* deleteUp */
             );
-          } else if (e === yt.id) {
-            const { range: n } = i.params;
+          } else if (cId === InsertRangeMoveDownCommand.id) {
+            const { range } = commandInfo.params;
             return this._getRangeMoveUndo(
-              n,
+              range,
               2
               /* insertDown */
             );
-          } else if (e === Ot.id) {
-            const { range: n } = i.params;
+          } else if (cId === InsertRangeMoveRightCommand.id) {
+            const { range } = commandInfo.params;
             return this._getRangeMoveUndo(
-              n,
+              range,
               3
               /* insertRight */
             );
-          } else if (e === Ut.id || e === At.id) {
-            const n = i.params, { unitId: t, subUnitId: r, ranges: s } = n;
-            return this._getDrawingUndoForRowVisible(t, r, s);
-          } else if (e === Nt.id || e === jt.id) {
-            const n = i.params, { unitId: t, subUnitId: r, ranges: s } = n;
-            return this._getDrawingUndoForColVisible(t, r, s);
-          } else if (e === qe.id || e === Qe.id || e === Pt.id || e === Tt.id) {
-            const n = i.params, { unitId: t, subUnitId: r, ranges: s } = n, o = e === qe.id || e === Qe.id;
-            return this._getDrawingUndoForRowAndColSize(t, r, s, o);
+          } else if (cId === SetRowHiddenCommand.id || cId === SetSpecificRowsVisibleCommand.id) {
+            const params = commandInfo.params, { unitId, subUnitId, ranges } = params;
+            return this._getDrawingUndoForRowVisible(unitId, subUnitId, ranges);
+          } else if (cId === SetSpecificColsVisibleCommand.id || cId === SetColHiddenCommand.id) {
+            const params = commandInfo.params, { unitId, subUnitId, ranges } = params;
+            return this._getDrawingUndoForColVisible(unitId, subUnitId, ranges);
+          } else if (cId === DeltaRowHeightCommand.id || cId === SetRowHeightCommand.id || cId === DeltaColumnWidthCommand.id || cId === SetColWidthCommand.id) {
+            const params = commandInfo.params, { unitId, subUnitId, ranges } = params, isRow = cId === DeltaRowHeightCommand.id || cId === SetRowHeightCommand.id;
+            return this._getDrawingUndoForRowAndColSize(unitId, subUnitId, ranges, isRow);
           }
           return { redos: [], undos: [] };
-        }
+        }, "getMutations")
       })
     );
   }
-  _getRangeMoveUndo(i, e) {
-    const n = le(this._univerInstanceService);
-    if (n == null)
+  _getRangeMoveUndo(range, type) {
+    const newParams = getSheetCommandTarget(this._univerInstanceService);
+    if (newParams == null)
       return { redos: [], undos: [] };
-    const t = n.unitId, r = n.subUnitId, s = [], o = [], a = this._sheetDrawingService.getDrawingData(t, r), d = [], h = [];
-    if (Object.keys(a).forEach((l) => {
-      const c = a[l], { updateDrawings: u, deleteDrawings: g } = this._getUpdateOrDeleteDrawings(i, e, c);
-      d.push(...u), h.push(...g);
-    }), d.length === 0 && h.length === 0)
+    const unitId = newParams.unitId, subUnitId = newParams.subUnitId, redos = [], undos = [], drawingData = this._sheetDrawingService.getDrawingData(unitId, subUnitId), updateDrawings = [], deleteDrawings = [];
+    if (Object.keys(drawingData).forEach((drawingId) => {
+      const drawing = drawingData[drawingId], { updateDrawings: updateDrawingsPart, deleteDrawings: deleteDrawingsPart } = this._getUpdateOrDeleteDrawings(range, type, drawing);
+      updateDrawings.push(...updateDrawingsPart), deleteDrawings.push(...deleteDrawingsPart);
+    }), updateDrawings.length === 0 && deleteDrawings.length === 0)
       return { redos: [], undos: [] };
-    if (d.length > 0) {
-      const l = this._sheetDrawingService.getBatchUpdateOp(d), { undo: c, redo: u, objects: g } = l;
-      s.push({ id: E.id, params: { unitId: t, subUnitId: r, op: u, objects: g, type: y.UPDATE } }), o.push({ id: E.id, params: { unitId: t, subUnitId: r, op: c, objects: g, type: y.UPDATE } });
+    if (updateDrawings.length > 0) {
+      const updateJsonOp = this._sheetDrawingService.getBatchUpdateOp(updateDrawings), { undo, redo, objects } = updateJsonOp;
+      redos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.UPDATE } }), undos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: undo, objects, type: DrawingApplyType.UPDATE } });
     }
-    if (h.length > 0) {
-      const l = this._sheetDrawingService.getBatchRemoveOp(h), c = l.undo, u = l.redo, g = l.objects;
-      s.push({ id: E.id, params: { unitId: t, subUnitId: r, op: u, objects: g, type: y.REMOVE } }), o.push({ id: E.id, params: { unitId: t, subUnitId: r, op: c, objects: g, type: y.INSERT } });
+    if (deleteDrawings.length > 0) {
+      const deleteJsonOp = this._sheetDrawingService.getBatchRemoveOp(deleteDrawings), deleteUndo = deleteJsonOp.undo, deleteRedo = deleteJsonOp.redo, deleteObjects = deleteJsonOp.objects;
+      redos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: deleteRedo, objects: deleteObjects, type: DrawingApplyType.REMOVE } }), undos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: deleteUndo, objects: deleteObjects, type: DrawingApplyType.INSERT } });
     }
-    return s.push({ id: j.id, params: [t] }), o.push({ id: j.id, params: [t] }), {
-      redos: s,
-      undos: o
+    return redos.push({ id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }), undos.push({ id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }), {
+      redos,
+      undos
     };
   }
-  _getUpdateOrDeleteDrawings(i, e, n) {
-    const t = [], r = [], { sheetTransform: s, anchorType: o = O.Position, transform: a, unitId: d, subUnitId: h, drawingId: l } = n, { from: c, to: u } = s, { row: g, column: f } = c, { row: m, column: p } = u;
-    if (s == null || a == null)
+  _getUpdateOrDeleteDrawings(range, type, drawing) {
+    const updateDrawings = [], deleteDrawings = [], { sheetTransform, anchorType = SheetDrawingAnchorType.Position, transform, unitId, subUnitId, drawingId } = drawing, { from, to } = sheetTransform, { row: fromRow, column: fromColumn } = from, { row: toRow, column: toColumn } = to;
+    if (sheetTransform == null || transform == null)
       return {
-        updateDrawings: t,
-        deleteDrawings: r
+        updateDrawings,
+        deleteDrawings
       };
-    const { startRow: S, endRow: C, startColumn: v, endColumn: R } = i;
-    let _ = null, b = null;
-    if (e === 0 && g >= S && m <= C)
-      if (f >= v && p <= R)
-        r.push({ unitId: d, subUnitId: h, drawingId: l });
+    const { startRow, endRow, startColumn, endColumn } = range;
+    let newSheetTransform = null, newTransform = null;
+    if (type === 0 && fromRow >= startRow && toRow <= endRow)
+      if (fromColumn >= startColumn && toColumn <= endColumn)
+        deleteDrawings.push({ unitId, subUnitId, drawingId });
       else {
-        const w = this._shrinkCol(s, a, v, R, o);
-        _ = w == null ? void 0 : w.newSheetTransform, b = w == null ? void 0 : w.newTransform;
+        const param = this._shrinkCol(sheetTransform, transform, startColumn, endColumn, anchorType);
+        newSheetTransform = param == null ? void 0 : param.newSheetTransform, newTransform = param == null ? void 0 : param.newTransform;
       }
-    else if (e === 1 && f >= v && p <= R)
-      if (g >= S && m <= C)
-        r.push({ unitId: d, subUnitId: h, drawingId: l });
+    else if (type === 1 && fromColumn >= startColumn && toColumn <= endColumn)
+      if (fromRow >= startRow && toRow <= endRow)
+        deleteDrawings.push({ unitId, subUnitId, drawingId });
       else {
-        const w = this._shrinkRow(s, a, S, C, o);
-        _ = w == null ? void 0 : w.newSheetTransform, b = w == null ? void 0 : w.newTransform;
+        const param = this._shrinkRow(sheetTransform, transform, startRow, endRow, anchorType);
+        newSheetTransform = param == null ? void 0 : param.newSheetTransform, newTransform = param == null ? void 0 : param.newTransform;
       }
-    else if (e === 2) {
-      const w = this._expandRow(s, a, S, C, o);
-      _ = w == null ? void 0 : w.newSheetTransform, b = w == null ? void 0 : w.newTransform;
-    } else if (e === 3) {
-      const w = this._expandCol(s, a, v, R, o);
-      _ = w == null ? void 0 : w.newSheetTransform, b = w == null ? void 0 : w.newTransform;
+    else if (type === 2) {
+      const param = this._expandRow(sheetTransform, transform, startRow, endRow, anchorType);
+      newSheetTransform = param == null ? void 0 : param.newSheetTransform, newTransform = param == null ? void 0 : param.newTransform;
+    } else if (type === 3) {
+      const param = this._expandCol(sheetTransform, transform, startColumn, endColumn, anchorType);
+      newSheetTransform = param == null ? void 0 : param.newSheetTransform, newTransform = param == null ? void 0 : param.newTransform;
     }
-    if (_ != null && b != null) {
-      const w = $(_, this._selectionRenderService, this._skeletonManagerService);
-      t.push({ ...n, sheetTransform: _, transform: w });
+    if (newSheetTransform != null && newTransform != null) {
+      const newTransform2 = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
+      updateDrawings.push({ ...drawing, sheetTransform: newSheetTransform, transform: newTransform2 });
     }
-    return { updateDrawings: t, deleteDrawings: r };
+    return { updateDrawings, deleteDrawings };
   }
-  _remainDrawingSize(i, e, n) {
-    const t = N({ ...i }, this._selectionRenderService);
-    t != null && e.push({
-      ...n,
-      sheetTransform: t
+  _remainDrawingSize(transform, updateDrawings, drawing) {
+    const newSheetTransform = transformToDrawingPosition({ ...transform }, this._selectionRenderService);
+    newSheetTransform != null && updateDrawings.push({
+      ...drawing,
+      sheetTransform: newSheetTransform
     });
   }
   // eslint-disable-next-line max-lines-per-function
-  _getDrawingUndoForColVisible(i, e, n) {
-    const t = this._drawingManagerService.getDrawingData(i, e), r = [], s = [];
-    if (Object.keys(t).forEach((l) => {
-      const c = t[l], { sheetTransform: u, transform: g, anchorType: f = O.Position } = c;
-      if (f === O.None)
-        this._remainDrawingSize(g, r, c);
+  _getDrawingUndoForColVisible(unitId, subUnitId, ranges) {
+    const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId), updateDrawings = [], preUpdateDrawings = [];
+    if (Object.keys(drawingData).forEach((drawingId) => {
+      const drawing = drawingData[drawingId], { sheetTransform, transform, anchorType = SheetDrawingAnchorType.Position } = drawing;
+      if (anchorType === SheetDrawingAnchorType.None)
+        this._remainDrawingSize(transform, updateDrawings, drawing);
       else {
-        const { from: m, to: p } = u, { row: S, column: C } = m, { row: v, column: R } = p;
-        for (let _ = 0; _ < n.length; _++) {
-          const b = n[_], { startRow: w, endRow: P, startColumn: D, endColumn: T } = b;
-          if (R < D)
+        const { from, to } = sheetTransform, { row: fromRow, column: fromColumn } = from, { row: toRow, column: toColumn } = to;
+        for (let i = 0; i < ranges.length; i++) {
+          const range = ranges[i], { startRow, endRow, startColumn, endColumn } = range;
+          if (toColumn < startColumn)
             continue;
-          if (f === O.Position) {
-            let I = null, A = null;
-            if (C >= D && C <= T) {
-              const G = this._skeletonManagerService.attachRangeWithCoord({ startColumn: C, endColumn: T, startRow: m.row, endRow: p.row });
-              if (G == null)
+          if (anchorType === SheetDrawingAnchorType.Position) {
+            let newSheetTransform2 = null, newTransform2 = null;
+            if (fromColumn >= startColumn && fromColumn <= endColumn) {
+              const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: fromColumn, endColumn, startRow: from.row, endRow: to.row });
+              if (selectionCell == null)
                 return;
-              A = { ...g, left: G.startX };
+              newTransform2 = { ...transform, left: selectionCell.startX };
             }
-            if (A != null && (I = N(A, this._selectionRenderService), I != null && A != null)) {
-              r.push({ ...c, sheetTransform: I, transform: A });
+            if (newTransform2 != null && (newSheetTransform2 = transformToDrawingPosition(newTransform2, this._selectionRenderService), newSheetTransform2 != null && newTransform2 != null)) {
+              updateDrawings.push({ ...drawing, sheetTransform: newSheetTransform2, transform: newTransform2 });
               break;
             }
-            this._remainDrawingSize(g, r, c);
+            this._remainDrawingSize(transform, updateDrawings, drawing);
             continue;
           }
-          if (C >= D && R <= T)
+          if (fromColumn >= startColumn && toColumn <= endColumn)
             continue;
-          let U = null, M = null;
-          if (C >= D && C <= T) {
-            const I = this._skeletonManagerService.attachRangeWithCoord({ startColumn: C, endColumn: T, startRow: m.row, endRow: p.row });
-            if (I == null)
+          let newSheetTransform = null, newTransform = null;
+          if (fromColumn >= startColumn && fromColumn <= endColumn) {
+            const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: fromColumn, endColumn, startRow: from.row, endRow: to.row });
+            if (selectionCell == null)
               return;
-            M = {
-              ...g,
-              left: (I == null ? void 0 : I.startX) || 0,
-              width: ((g == null ? void 0 : g.width) || 0) - I.endX + I.startX
+            newTransform = {
+              ...transform,
+              left: (selectionCell == null ? void 0 : selectionCell.startX) || 0,
+              width: ((transform == null ? void 0 : transform.width) || 0) - selectionCell.endX + selectionCell.startX
             };
-          } else if (R >= D && R <= T) {
-            const I = this._skeletonManagerService.attachRangeWithCoord({ startColumn: D, endColumn: R, startRow: m.row, endRow: p.row });
-            if (I == null)
+          } else if (toColumn >= startColumn && toColumn <= endColumn) {
+            const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn, endColumn: toColumn, startRow: from.row, endRow: to.row });
+            if (selectionCell == null)
               return;
-            M = {
-              ...g,
-              left: I.startX - ((g == null ? void 0 : g.width) || 0)
+            newTransform = {
+              ...transform,
+              left: selectionCell.startX - ((transform == null ? void 0 : transform.width) || 0)
             };
           } else {
-            const I = this._skeletonManagerService.attachRangeWithCoord({ startColumn: D, endColumn: T, startRow: m.row, endRow: p.row });
-            if (I == null)
+            const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn, endColumn, startRow: from.row, endRow: to.row });
+            if (selectionCell == null)
               return;
-            if (M = {
-              ...g,
-              width: ((g == null ? void 0 : g.width) || 0) - I.endX + I.startX
-            }, U = N(M, this._selectionRenderService), U != null && M != null) {
-              s.push({ ...c, sheetTransform: U, transform: M });
+            if (newTransform = {
+              ...transform,
+              width: ((transform == null ? void 0 : transform.width) || 0) - selectionCell.endX + selectionCell.startX
+            }, newSheetTransform = transformToDrawingPosition(newTransform, this._selectionRenderService), newSheetTransform != null && newTransform != null) {
+              preUpdateDrawings.push({ ...drawing, sheetTransform: newSheetTransform, transform: newTransform });
               break;
             }
           }
-          if (M != null && (U = N(M, this._selectionRenderService)), M != null && U != null) {
-            r.push({ ...c, sheetTransform: U, transform: M });
+          if (newTransform != null && (newSheetTransform = transformToDrawingPosition(newTransform, this._selectionRenderService)), newTransform != null && newSheetTransform != null) {
+            updateDrawings.push({ ...drawing, sheetTransform: newSheetTransform, transform: newTransform });
             break;
           } else
-            this._remainDrawingSize(g, r, c);
+            this._remainDrawingSize(transform, updateDrawings, drawing);
         }
       }
-    }), r.length === 0 && s.length === 0)
+    }), updateDrawings.length === 0 && preUpdateDrawings.length === 0)
       return { redos: [], undos: [] };
-    const { redos: o, undos: a } = this._createUndoAndRedoMutation(i, e, r), d = [], h = [];
-    if (s.length > 0) {
-      const { redos: l, undos: c } = this._createUndoAndRedoMutation(i, e, s);
-      d.push(...l), h.push(...c);
+    const { redos, undos } = this._createUndoAndRedoMutation(unitId, subUnitId, updateDrawings), preRedos = [], preUndos = [];
+    if (preUpdateDrawings.length > 0) {
+      const { redos: redos2, undos: undos2 } = this._createUndoAndRedoMutation(unitId, subUnitId, preUpdateDrawings);
+      preRedos.push(...redos2), preUndos.push(...undos2);
     }
     return {
-      redos: o,
-      undos: a,
-      preRedos: d,
-      preUndos: h
+      redos,
+      undos,
+      preRedos,
+      preUndos
     };
   }
-  _createUndoAndRedoMutation(i, e, n) {
-    const t = this._sheetDrawingService.getBatchUpdateOp(n), { undo: r, redo: s, objects: o } = t, a = [
-      { id: E.id, params: { unitId: i, subUnitId: e, op: s, objects: o, type: y.UPDATE } },
-      { id: j.id, params: [i] }
-    ], d = [
-      { id: E.id, params: { unitId: i, subUnitId: e, op: r, objects: o, type: y.UPDATE } },
-      { id: j.id, params: [i] }
+  _createUndoAndRedoMutation(unitId, subUnitId, updateDrawings) {
+    const updateJsonOp = this._sheetDrawingService.getBatchUpdateOp(updateDrawings), { undo, redo, objects } = updateJsonOp, redos = [
+      { id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.UPDATE } },
+      { id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }
+    ], undos = [
+      { id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: undo, objects, type: DrawingApplyType.UPDATE } },
+      { id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }
     ];
     return {
-      redos: a,
-      undos: d
+      redos,
+      undos
     };
   }
   // eslint-disable-next-line max-lines-per-function
-  _getDrawingUndoForRowVisible(i, e, n) {
-    const t = this._drawingManagerService.getDrawingData(i, e), r = [], s = [];
-    if (Object.keys(t).forEach((l) => {
-      const c = t[l], { sheetTransform: u, transform: g, anchorType: f = O.Position } = c;
-      if (f === O.None)
-        this._remainDrawingSize(g, r, c);
+  _getDrawingUndoForRowVisible(unitId, subUnitId, ranges) {
+    const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId), updateDrawings = [], preUpdateDrawings = [];
+    if (Object.keys(drawingData).forEach((drawingId) => {
+      const drawing = drawingData[drawingId], { sheetTransform, transform, anchorType = SheetDrawingAnchorType.Position } = drawing;
+      if (anchorType === SheetDrawingAnchorType.None)
+        this._remainDrawingSize(transform, updateDrawings, drawing);
       else {
-        const { from: m, to: p } = u, { row: S, column: C } = m, { row: v, column: R } = p;
-        for (let _ = 0; _ < n.length; _++) {
-          const b = n[_], { startRow: w, endRow: P, startColumn: D, endColumn: T } = b;
-          if (v < w)
+        const { from, to } = sheetTransform, { row: fromRow, column: fromColumn } = from, { row: toRow, column: toColumn } = to;
+        for (let i = 0; i < ranges.length; i++) {
+          const range = ranges[i], { startRow, endRow, startColumn, endColumn } = range;
+          if (toRow < startRow)
             continue;
-          if (f === O.Position) {
-            let I = null, A = null;
-            if (S >= w && S <= P) {
-              const G = this._skeletonManagerService.attachRangeWithCoord({ startColumn: m.column, endColumn: p.column, startRow: S, endRow: P });
-              if (G == null)
+          if (anchorType === SheetDrawingAnchorType.Position) {
+            let newSheetTransform2 = null, newTransform2 = null;
+            if (fromRow >= startRow && fromRow <= endRow) {
+              const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: from.column, endColumn: to.column, startRow: fromRow, endRow });
+              if (selectionCell == null)
                 return;
-              A = { ...g, top: G.startY };
+              newTransform2 = { ...transform, top: selectionCell.startY };
             }
-            if (A != null && (I = N(A, this._selectionRenderService), I != null && A != null)) {
-              r.push({ ...c, sheetTransform: I, transform: A });
+            if (newTransform2 != null && (newSheetTransform2 = transformToDrawingPosition(newTransform2, this._selectionRenderService), newSheetTransform2 != null && newTransform2 != null)) {
+              updateDrawings.push({ ...drawing, sheetTransform: newSheetTransform2, transform: newTransform2 });
               break;
             }
-            this._remainDrawingSize(g, r, c);
+            this._remainDrawingSize(transform, updateDrawings, drawing);
             continue;
           }
-          if (S >= w && v <= P)
+          if (fromRow >= startRow && toRow <= endRow)
             continue;
-          let U = null, M = null;
-          if (S >= w && S <= P) {
-            const I = this._skeletonManagerService.attachRangeWithCoord({ startColumn: m.column, endColumn: p.column, startRow: S, endRow: P });
-            if (I == null)
+          let newSheetTransform = null, newTransform = null;
+          if (fromRow >= startRow && fromRow <= endRow) {
+            const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: from.column, endColumn: to.column, startRow: fromRow, endRow });
+            if (selectionCell == null)
               return;
-            M = {
-              ...g,
-              top: (I == null ? void 0 : I.startY) || 0,
-              height: ((g == null ? void 0 : g.height) || 0) - I.endY + I.startY
+            newTransform = {
+              ...transform,
+              top: (selectionCell == null ? void 0 : selectionCell.startY) || 0,
+              height: ((transform == null ? void 0 : transform.height) || 0) - selectionCell.endY + selectionCell.startY
             };
-          } else if (v >= w && v <= P) {
-            const I = this._skeletonManagerService.attachRangeWithCoord({ startColumn: m.column, endColumn: p.column, startRow: w, endRow: v });
-            if (I == null)
+          } else if (toRow >= startRow && toRow <= endRow) {
+            const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: from.column, endColumn: to.column, startRow, endRow: toRow });
+            if (selectionCell == null)
               return;
-            M = {
-              ...g,
-              top: I.startY - ((g == null ? void 0 : g.height) || 0)
+            newTransform = {
+              ...transform,
+              top: selectionCell.startY - ((transform == null ? void 0 : transform.height) || 0)
             };
           } else {
-            const I = this._skeletonManagerService.attachRangeWithCoord({ startColumn: m.column, endColumn: p.column, startRow: w, endRow: P });
-            if (I == null)
+            const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: from.column, endColumn: to.column, startRow, endRow });
+            if (selectionCell == null)
               return;
-            if (M = {
-              ...g,
-              height: ((g == null ? void 0 : g.height) || 0) - I.endY + I.startY
-            }, U = N(M, this._selectionRenderService), U != null && M != null) {
-              s.push({ ...c, sheetTransform: U, transform: M });
+            if (newTransform = {
+              ...transform,
+              height: ((transform == null ? void 0 : transform.height) || 0) - selectionCell.endY + selectionCell.startY
+            }, newSheetTransform = transformToDrawingPosition(newTransform, this._selectionRenderService), newSheetTransform != null && newTransform != null) {
+              preUpdateDrawings.push({ ...drawing, sheetTransform: newSheetTransform, transform: newTransform });
               break;
             }
           }
-          if (M != null && (U = N(M, this._selectionRenderService)), M != null && U != null) {
-            r.push({ ...c, sheetTransform: U, transform: M });
+          if (newTransform != null && (newSheetTransform = transformToDrawingPosition(newTransform, this._selectionRenderService)), newTransform != null && newSheetTransform != null) {
+            updateDrawings.push({ ...drawing, sheetTransform: newSheetTransform, transform: newTransform });
             break;
           } else
-            this._remainDrawingSize(g, r, c);
+            this._remainDrawingSize(transform, updateDrawings, drawing);
         }
       }
-    }), r.length === 0 && s.length === 0)
+    }), updateDrawings.length === 0 && preUpdateDrawings.length === 0)
       return { redos: [], undos: [] };
-    const { redos: o, undos: a } = this._createUndoAndRedoMutation(i, e, r), d = [], h = [];
-    if (s.length > 0) {
-      const { redos: l, undos: c } = this._createUndoAndRedoMutation(i, e, s);
-      d.push(...l), h.push(...c);
+    const { redos, undos } = this._createUndoAndRedoMutation(unitId, subUnitId, updateDrawings), preRedos = [], preUndos = [];
+    if (preUpdateDrawings.length > 0) {
+      const { redos: redos2, undos: undos2 } = this._createUndoAndRedoMutation(unitId, subUnitId, preUpdateDrawings);
+      preRedos.push(...redos2), preUndos.push(...undos2);
     }
     return {
-      redos: o,
-      undos: a,
-      preRedos: d,
-      preUndos: h
+      redos,
+      undos,
+      preRedos,
+      preUndos
     };
   }
-  _getDrawingUndoForRowAndColSize(i, e, n, t) {
-    const r = this._drawingManagerService.getDrawingData(i, e), s = [];
-    return Object.keys(r).forEach((o) => {
-      const a = r[o], { sheetTransform: d, transform: h, anchorType: l = O.Position } = a;
-      if (l === O.None)
-        this._remainDrawingSize(h, s, a);
+  _getDrawingUndoForRowAndColSize(unitId, subUnitId, ranges, isRow) {
+    const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId), updateDrawings = [];
+    return Object.keys(drawingData).forEach((drawingId) => {
+      const drawing = drawingData[drawingId], { sheetTransform, transform, anchorType = SheetDrawingAnchorType.Position } = drawing;
+      if (anchorType === SheetDrawingAnchorType.None)
+        this._remainDrawingSize(transform, updateDrawings, drawing);
       else {
-        const { from: c, to: u } = d, { row: g, column: f } = c, { row: m, column: p } = u;
-        for (let S = 0; S < n.length; S++) {
-          const C = n[S], { startRow: v, endRow: R, startColumn: _, endColumn: b } = C;
-          if (m < v || p < _)
+        const { from, to } = sheetTransform, { row: fromRow, column: fromColumn } = from, { row: toRow, column: toColumn } = to;
+        for (let i = 0; i < ranges.length; i++) {
+          const range = ranges[i], { startRow, endRow, startColumn, endColumn } = range;
+          if (toRow < startRow || toColumn < startColumn)
             continue;
-          if (l === O.Position && (g <= v && m >= R || f <= _ && p >= b)) {
-            this._remainDrawingSize(h, s, a);
+          if (anchorType === SheetDrawingAnchorType.Position && (fromRow <= startRow && toRow >= endRow || fromColumn <= startColumn && toColumn >= endColumn)) {
+            this._remainDrawingSize(transform, updateDrawings, drawing);
             continue;
           }
-          const w = $(
-            { ...d },
+          const newTransform = drawingPositionToTransform(
+            { ...sheetTransform },
             this._selectionRenderService,
             this._skeletonManagerService
           );
-          if (w != null) {
-            s.push({
-              ...a,
-              transform: w
+          if (newTransform != null) {
+            updateDrawings.push({
+              ...drawing,
+              transform: newTransform
             });
             break;
           }
         }
       }
-    }), s.length === 0 ? { redos: [], undos: [] } : this._createUndoAndRedoMutation(i, e, s);
+    }), updateDrawings.length === 0 ? { redos: [], undos: [] } : this._createUndoAndRedoMutation(unitId, subUnitId, updateDrawings);
   }
-  _getUnitIdAndSubUnitId(i, e) {
-    let n, t;
-    if (e === "insert")
-      n = i.unitId, t = i.subUnitId;
+  _getUnitIdAndSubUnitId(params, type) {
+    let unitId, subUnitId;
+    if (type === "insert")
+      unitId = params.unitId, subUnitId = params.subUnitId;
     else {
-      const r = le(this._univerInstanceService);
-      if (r == null)
+      const newParams = getSheetCommandTarget(this._univerInstanceService);
+      if (newParams == null)
         return;
-      n = r.unitId, t = r.subUnitId;
+      unitId = newParams.unitId, subUnitId = newParams.subUnitId;
     }
-    return { unitId: n, subUnitId: t };
+    return { unitId, subUnitId };
   }
-  _moveRowInterceptor(i, e) {
-    const n = this._getUnitIdAndSubUnitId(i, e);
-    if (n == null)
+  _moveRowInterceptor(params, type) {
+    const ids = this._getUnitIdAndSubUnitId(params, type);
+    if (ids == null)
       return { redos: [], undos: [] };
-    const { unitId: t, subUnitId: r } = n, { range: s } = i, o = s.startRow, a = s.endRow, d = [], h = [], l = this._sheetDrawingService.getDrawingData(t, r), c = [], u = [];
-    if (Object.keys(l).forEach((g) => {
-      const f = l[g], { sheetTransform: m, transform: p, anchorType: S = O.Position } = f;
-      if (m == null || p == null)
+    const { unitId, subUnitId } = ids, { range } = params, rowStartIndex = range.startRow, rowEndIndex = range.endRow, redos = [], undos = [], data = this._sheetDrawingService.getDrawingData(unitId, subUnitId), updateDrawings = [], deleteDrawings = [];
+    if (Object.keys(data).forEach((drawingId) => {
+      const drawing = data[drawingId], { sheetTransform, transform, anchorType = SheetDrawingAnchorType.Position } = drawing;
+      if (sheetTransform == null || transform == null)
         return;
-      let C, v;
-      if (e === "insert") {
-        const _ = this._expandRow(m, p, o, a, S);
-        C = _ == null ? void 0 : _.newSheetTransform, v = _ == null ? void 0 : _.newTransform;
+      let newSheetTransform, newTransform;
+      if (type === "insert") {
+        const param = this._expandRow(sheetTransform, transform, rowStartIndex, rowEndIndex, anchorType);
+        newSheetTransform = param == null ? void 0 : param.newSheetTransform, newTransform = param == null ? void 0 : param.newTransform;
       } else {
-        const { from: _, to: b } = m, { row: w } = _, { row: P } = b;
-        if (w >= o && P <= a)
-          u.push({ unitId: t, subUnitId: r, drawingId: g });
+        const { from, to } = sheetTransform, { row: fromRow } = from, { row: toRow } = to;
+        if (fromRow >= rowStartIndex && toRow <= rowEndIndex)
+          deleteDrawings.push({ unitId, subUnitId, drawingId });
         else {
-          const D = this._shrinkRow(m, p, o, a, S);
-          C = D == null ? void 0 : D.newSheetTransform, v = D == null ? void 0 : D.newTransform;
+          const param = this._shrinkRow(sheetTransform, transform, rowStartIndex, rowEndIndex, anchorType);
+          newSheetTransform = param == null ? void 0 : param.newSheetTransform, newTransform = param == null ? void 0 : param.newTransform;
         }
       }
-      if (!C || !v)
+      if (!newSheetTransform || !newTransform)
         return;
-      const R = { unitId: t, subUnitId: r, drawingId: g, transform: v, sheetTransform: C };
-      c.push(R);
-    }), c.length === 0 && u.length === 0)
+      const params2 = { unitId, subUnitId, drawingId, transform: newTransform, sheetTransform: newSheetTransform };
+      updateDrawings.push(params2);
+    }), updateDrawings.length === 0 && deleteDrawings.length === 0)
       return { redos: [], undos: [] };
-    if (c.length > 0) {
-      const g = this._sheetDrawingService.getBatchUpdateOp(c), { undo: f, redo: m, objects: p } = g;
-      d.push({ id: E.id, params: { unitId: t, subUnitId: r, op: m, objects: p, type: y.UPDATE } }), h.push({ id: E.id, params: { unitId: t, subUnitId: r, op: f, objects: p, type: y.UPDATE } });
+    if (updateDrawings.length > 0) {
+      const updateJsonOp = this._sheetDrawingService.getBatchUpdateOp(updateDrawings), { undo, redo, objects } = updateJsonOp;
+      redos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.UPDATE } }), undos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: undo, objects, type: DrawingApplyType.UPDATE } });
     }
-    if (u.length > 0) {
-      const g = this._sheetDrawingService.getBatchRemoveOp(u), f = g.undo, m = g.redo, p = g.objects;
-      d.push({ id: E.id, params: { unitId: t, subUnitId: r, op: m, objects: p, type: y.REMOVE } }), h.push({ id: E.id, params: { unitId: t, subUnitId: r, op: f, objects: p, type: y.INSERT } });
+    if (deleteDrawings.length > 0) {
+      const deleteJsonOp = this._sheetDrawingService.getBatchRemoveOp(deleteDrawings), deleteUndo = deleteJsonOp.undo, deleteRedo = deleteJsonOp.redo, deleteObjects = deleteJsonOp.objects;
+      redos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: deleteRedo, objects: deleteObjects, type: DrawingApplyType.REMOVE } }), undos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: deleteUndo, objects: deleteObjects, type: DrawingApplyType.INSERT } });
     }
-    return d.push({ id: j.id, params: [t] }), h.push({ id: j.id, params: [t] }), {
-      redos: d,
-      undos: h
+    return redos.push({ id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }), undos.push({ id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }), {
+      redos,
+      undos
     };
   }
-  _moveColInterceptor(i, e) {
-    const n = this._getUnitIdAndSubUnitId(i, e);
-    if (n == null)
+  _moveColInterceptor(params, type) {
+    const ids = this._getUnitIdAndSubUnitId(params, type);
+    if (ids == null)
       return { redos: [], undos: [] };
-    const { unitId: t, subUnitId: r } = n, { range: s } = i, o = s.startColumn, a = s.endColumn, d = [], h = [], l = this._sheetDrawingService.getDrawingData(t, r), c = [], u = [];
-    if (Object.keys(l).forEach((g) => {
-      const f = l[g], { sheetTransform: m, transform: p, anchorType: S = O.Position } = f;
-      if (m == null || p == null)
+    const { unitId, subUnitId } = ids, { range } = params, colStartIndex = range.startColumn, colEndIndex = range.endColumn, redos = [], undos = [], data = this._sheetDrawingService.getDrawingData(unitId, subUnitId), updateDrawings = [], deleteDrawings = [];
+    if (Object.keys(data).forEach((drawingId) => {
+      const drawing = data[drawingId], { sheetTransform, transform, anchorType = SheetDrawingAnchorType.Position } = drawing;
+      if (sheetTransform == null || transform == null)
         return;
-      let C, v;
-      if (e === "insert") {
-        const _ = this._expandCol(m, p, o, a, S);
-        C = _ == null ? void 0 : _.newSheetTransform, v = _ == null ? void 0 : _.newTransform;
+      let newSheetTransform, newTransform;
+      if (type === "insert") {
+        const param = this._expandCol(sheetTransform, transform, colStartIndex, colEndIndex, anchorType);
+        newSheetTransform = param == null ? void 0 : param.newSheetTransform, newTransform = param == null ? void 0 : param.newTransform;
       } else {
-        const { from: _, to: b } = m, { column: w } = _, { column: P } = b;
-        if (w >= o && P <= a)
-          u.push({ unitId: t, subUnitId: r, drawingId: g });
+        const { from, to } = sheetTransform, { column: fromColumn } = from, { column: toColumn } = to;
+        if (fromColumn >= colStartIndex && toColumn <= colEndIndex)
+          deleteDrawings.push({ unitId, subUnitId, drawingId });
         else {
-          const D = this._shrinkCol(m, p, o, a, S);
-          C = D == null ? void 0 : D.newSheetTransform, v = D == null ? void 0 : D.newTransform;
+          const param = this._shrinkCol(sheetTransform, transform, colStartIndex, colEndIndex, anchorType);
+          newSheetTransform = param == null ? void 0 : param.newSheetTransform, newTransform = param == null ? void 0 : param.newTransform;
         }
       }
-      if (!C || !v)
+      if (!newSheetTransform || !newTransform)
         return;
-      const R = { unitId: t, subUnitId: r, drawingId: g, transform: v, sheetTransform: C };
-      c.push(R);
-    }), c.length === 0 && u.length === 0)
+      const params2 = { unitId, subUnitId, drawingId, transform: newTransform, sheetTransform: newSheetTransform };
+      updateDrawings.push(params2);
+    }), updateDrawings.length === 0 && deleteDrawings.length === 0)
       return { redos: [], undos: [] };
-    if (c.length > 0) {
-      const g = this._sheetDrawingService.getBatchUpdateOp(c), { undo: f, redo: m, objects: p } = g;
-      d.push({ id: E.id, params: { unitId: t, subUnitId: r, op: m, objects: p, type: y.UPDATE } }), h.push({ id: E.id, params: { unitId: t, subUnitId: r, op: f, objects: p, type: y.UPDATE } });
+    if (updateDrawings.length > 0) {
+      const updateJsonOp = this._sheetDrawingService.getBatchUpdateOp(updateDrawings), { undo, redo, objects } = updateJsonOp;
+      redos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.UPDATE } }), undos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: undo, objects, type: DrawingApplyType.UPDATE } });
     }
-    if (u.length > 0) {
-      const g = this._sheetDrawingService.getBatchRemoveOp(u), f = g.undo, m = g.redo, p = g.objects;
-      d.push({ id: E.id, params: { unitId: t, subUnitId: r, op: m, objects: p, type: y.REMOVE } }), h.push({ id: E.id, params: { unitId: t, subUnitId: r, op: f, objects: p, type: y.INSERT } });
+    if (deleteDrawings.length > 0) {
+      const deleteJsonOp = this._sheetDrawingService.getBatchRemoveOp(deleteDrawings), deleteUndo = deleteJsonOp.undo, deleteRedo = deleteJsonOp.redo, deleteObjects = deleteJsonOp.objects;
+      redos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: deleteRedo, objects: deleteObjects, type: DrawingApplyType.REMOVE } }), undos.push({ id: SetDrawingApplyMutation.id, params: { unitId, subUnitId, op: deleteUndo, objects: deleteObjects, type: DrawingApplyType.INSERT } });
     }
-    return d.push({ id: j.id, params: [t] }), h.push({ id: j.id, params: [t] }), { redos: d, undos: h };
+    return redos.push({ id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }), undos.push({ id: ClearSheetDrawingTransformerOperation.id, params: [unitId] }), { redos, undos };
   }
-  _expandCol(i, e, n, t, r = O.Position) {
-    const s = t - n + 1, { from: o, to: a } = i, { column: d } = o, { column: h } = a;
-    if (r === O.None)
+  _expandCol(sheetTransform, transform, colStartIndex, colEndIndex, anchorType = SheetDrawingAnchorType.Position) {
+    const colCount = colEndIndex - colStartIndex + 1, { from, to } = sheetTransform, { column: fromColumn } = from, { column: toColumn } = to;
+    if (anchorType === SheetDrawingAnchorType.None)
       return {
-        newSheetTransform: N({ ...e }, this._selectionRenderService),
-        newTransform: e
+        newSheetTransform: transformToDrawingPosition({ ...transform }, this._selectionRenderService),
+        newTransform: transform
       };
-    let l = null, c = null;
-    if (d >= n) {
-      const u = this._skeletonManagerService.attachRangeWithCoord({ startColumn: n, endColumn: t, startRow: o.row, endRow: a.row });
-      if (u == null)
+    let newSheetTransform = null, newTransform = null;
+    if (fromColumn >= colStartIndex) {
+      const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: colStartIndex, endColumn: colEndIndex, startRow: from.row, endRow: to.row });
+      if (selectionCell == null)
         return;
-      c = { ...e, left: (e.left || 0) + u.endX - u.startX }, l = N(c, this._selectionRenderService);
-    } else if (h >= t)
-      if (r === O.Both)
-        l = {
-          from: { ...o },
-          to: { ...a, column: h + s }
-        }, c = $(l, this._selectionRenderService, this._skeletonManagerService);
+      newTransform = { ...transform, left: (transform.left || 0) + selectionCell.endX - selectionCell.startX }, newSheetTransform = transformToDrawingPosition(newTransform, this._selectionRenderService);
+    } else if (toColumn >= colEndIndex)
+      if (anchorType === SheetDrawingAnchorType.Both)
+        newSheetTransform = {
+          from: { ...from },
+          to: { ...to, column: toColumn + colCount }
+        }, newTransform = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
       else
         return {
-          newSheetTransform: N({ ...e }, this._selectionRenderService),
-          newTransform: e
+          newSheetTransform: transformToDrawingPosition({ ...transform }, this._selectionRenderService),
+          newTransform: transform
         };
-    return l != null && c != null ? {
-      newSheetTransform: l,
-      newTransform: c
+    return newSheetTransform != null && newTransform != null ? {
+      newSheetTransform,
+      newTransform
     } : null;
   }
-  _shrinkCol(i, e, n, t, r = O.Position) {
-    const s = t - n + 1, { from: o, to: a } = i, { column: d } = o, { column: h } = a;
-    if (r === O.None)
+  _shrinkCol(sheetTransform, transform, colStartIndex, colEndIndex, anchorType = SheetDrawingAnchorType.Position) {
+    const colCount = colEndIndex - colStartIndex + 1, { from, to } = sheetTransform, { column: fromColumn } = from, { column: toColumn } = to;
+    if (anchorType === SheetDrawingAnchorType.None)
       return {
-        newSheetTransform: N({ ...e }, this._selectionRenderService),
-        newTransform: e
+        newSheetTransform: transformToDrawingPosition({ ...transform }, this._selectionRenderService),
+        newTransform: transform
       };
-    let l = null, c = null;
-    if (d > t)
-      l = {
-        from: { ...o, column: d - s },
-        to: { ...a, column: h - s }
-      }, c = $(l, this._selectionRenderService, this._skeletonManagerService);
+    let newSheetTransform = null, newTransform = null;
+    if (fromColumn > colEndIndex)
+      newSheetTransform = {
+        from: { ...from, column: fromColumn - colCount },
+        to: { ...to, column: toColumn - colCount }
+      }, newTransform = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
     else {
-      if (d >= n && h <= t)
+      if (fromColumn >= colStartIndex && toColumn <= colEndIndex)
         return null;
-      if (d < n && h > t)
-        if (r === O.Both)
-          l = {
-            from: { ...o },
-            to: { ...a, column: h - s }
-          }, c = $(l, this._selectionRenderService, this._skeletonManagerService);
+      if (fromColumn < colStartIndex && toColumn > colEndIndex)
+        if (anchorType === SheetDrawingAnchorType.Both)
+          newSheetTransform = {
+            from: { ...from },
+            to: { ...to, column: toColumn - colCount }
+          }, newTransform = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
         else
           return {
-            newSheetTransform: N({ ...e }, this._selectionRenderService),
-            newTransform: e
+            newSheetTransform: transformToDrawingPosition({ ...transform }, this._selectionRenderService),
+            newTransform: transform
           };
-      else if (d >= n && d <= t) {
-        if (d === n)
-          c = { ...e, left: (e.left || 0) - i.from.columnOffset };
+      else if (fromColumn >= colStartIndex && fromColumn <= colEndIndex) {
+        if (fromColumn === colStartIndex)
+          newTransform = { ...transform, left: (transform.left || 0) - sheetTransform.from.columnOffset };
         else {
-          const u = this._skeletonManagerService.attachRangeWithCoord({ startColumn: n, endColumn: d - 1, startRow: o.row, endRow: a.row });
-          if (u == null)
+          const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: colStartIndex, endColumn: fromColumn - 1, startRow: from.row, endRow: to.row });
+          if (selectionCell == null)
             return;
-          c = { ...e, left: (e.left || 0) - u.endX + u.startX - i.from.columnOffset };
+          newTransform = { ...transform, left: (transform.left || 0) - selectionCell.endX + selectionCell.startX - sheetTransform.from.columnOffset };
         }
-        l = N(c, this._selectionRenderService);
-      } else if (h >= n && h <= t && r === O.Both) {
-        const u = this._skeletonManagerService.attachRangeWithCoord({
-          startColumn: n - 1,
-          endColumn: n - 1,
-          startRow: o.row,
-          endRow: a.row
+        newSheetTransform = transformToDrawingPosition(newTransform, this._selectionRenderService);
+      } else if (toColumn >= colStartIndex && toColumn <= colEndIndex && anchorType === SheetDrawingAnchorType.Both) {
+        const selectionCell = this._skeletonManagerService.attachRangeWithCoord({
+          startColumn: colStartIndex - 1,
+          endColumn: colStartIndex - 1,
+          startRow: from.row,
+          endRow: to.row
         });
-        if (u == null)
+        if (selectionCell == null)
           return;
-        l = {
-          from: { ...o },
-          to: { ...a, column: n - 1, columnOffset: u.endX - u.startX }
-        }, c = $(l, this._selectionRenderService, this._skeletonManagerService);
+        newSheetTransform = {
+          from: { ...from },
+          to: { ...to, column: colStartIndex - 1, columnOffset: selectionCell.endX - selectionCell.startX }
+        }, newTransform = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
       }
     }
-    return l != null && c != null ? {
-      newSheetTransform: l,
-      newTransform: c
+    return newSheetTransform != null && newTransform != null ? {
+      newSheetTransform,
+      newTransform
     } : null;
   }
-  _expandRow(i, e, n, t, r = O.Position) {
-    const s = t - n + 1, { from: o, to: a } = i, { row: d } = o, { row: h } = a;
-    if (r === O.None)
+  _expandRow(sheetTransform, transform, rowStartIndex, rowEndIndex, anchorType = SheetDrawingAnchorType.Position) {
+    const rowCount = rowEndIndex - rowStartIndex + 1, { from, to } = sheetTransform, { row: fromRow } = from, { row: toRow } = to;
+    if (anchorType === SheetDrawingAnchorType.None)
       return {
-        newSheetTransform: N({ ...e }, this._selectionRenderService),
-        newTransform: e
+        newSheetTransform: transformToDrawingPosition({ ...transform }, this._selectionRenderService),
+        newTransform: transform
       };
-    let l = null, c = null;
-    if (d >= n) {
-      const u = this._skeletonManagerService.attachRangeWithCoord({ startRow: n, endRow: t, startColumn: o.column, endColumn: a.column });
-      if (u == null)
+    let newSheetTransform = null, newTransform = null;
+    if (fromRow >= rowStartIndex) {
+      const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startRow: rowStartIndex, endRow: rowEndIndex, startColumn: from.column, endColumn: to.column });
+      if (selectionCell == null)
         return;
-      c = { ...e, top: (e.top || 0) + u.endY - u.startY }, l = N(c, this._selectionRenderService);
-    } else if (h >= t)
-      if (r === O.Both)
-        l = {
-          from: { ...o },
+      newTransform = { ...transform, top: (transform.top || 0) + selectionCell.endY - selectionCell.startY }, newSheetTransform = transformToDrawingPosition(newTransform, this._selectionRenderService);
+    } else if (toRow >= rowEndIndex)
+      if (anchorType === SheetDrawingAnchorType.Both)
+        newSheetTransform = {
+          from: { ...from },
           to: {
-            ...a,
-            row: h + s
+            ...to,
+            row: toRow + rowCount
           }
-        }, c = $(l, this._selectionRenderService, this._skeletonManagerService);
+        }, newTransform = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
       else
         return {
-          newSheetTransform: N({ ...e }, this._selectionRenderService),
-          newTransform: e
+          newSheetTransform: transformToDrawingPosition({ ...transform }, this._selectionRenderService),
+          newTransform: transform
         };
-    return l != null && c != null ? {
-      newSheetTransform: l,
-      newTransform: c
+    return newSheetTransform != null && newTransform != null ? {
+      newSheetTransform,
+      newTransform
     } : null;
   }
-  _shrinkRow(i, e, n, t, r = O.Position) {
-    const s = t - n + 1, { from: o, to: a } = i, { row: d } = o, { row: h } = a;
-    if (r === O.None)
+  _shrinkRow(sheetTransform, transform, rowStartIndex, rowEndIndex, anchorType = SheetDrawingAnchorType.Position) {
+    const rowCount = rowEndIndex - rowStartIndex + 1, { from, to } = sheetTransform, { row: fromRow } = from, { row: toRow } = to;
+    if (anchorType === SheetDrawingAnchorType.None)
       return {
-        newSheetTransform: N({ ...e }, this._selectionRenderService),
-        newTransform: e
+        newSheetTransform: transformToDrawingPosition({ ...transform }, this._selectionRenderService),
+        newTransform: transform
       };
-    let l = null, c = null;
-    if (d > t)
-      l = {
-        from: { ...o, row: d - s },
-        to: { ...a, row: h - s }
-      }, c = $(l, this._selectionRenderService, this._skeletonManagerService);
+    let newSheetTransform = null, newTransform = null;
+    if (fromRow > rowEndIndex)
+      newSheetTransform = {
+        from: { ...from, row: fromRow - rowCount },
+        to: { ...to, row: toRow - rowCount }
+      }, newTransform = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
     else {
-      if (d >= n && h <= t)
+      if (fromRow >= rowStartIndex && toRow <= rowEndIndex)
         return null;
-      if (d < n && h > t)
-        if (r === O.Both)
-          l = {
-            from: { ...o },
-            to: { ...a, row: h - s }
-          }, c = $(l, this._selectionRenderService, this._skeletonManagerService);
+      if (fromRow < rowStartIndex && toRow > rowEndIndex)
+        if (anchorType === SheetDrawingAnchorType.Both)
+          newSheetTransform = {
+            from: { ...from },
+            to: { ...to, row: toRow - rowCount }
+          }, newTransform = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
         else
           return {
-            newSheetTransform: N({ ...e }, this._selectionRenderService),
-            newTransform: e
+            newSheetTransform: transformToDrawingPosition({ ...transform }, this._selectionRenderService),
+            newTransform: transform
           };
-      else if (d >= n && d <= t) {
-        if (d === n)
-          c = { ...e, top: (e.top || 0) - i.from.rowOffset };
+      else if (fromRow >= rowStartIndex && fromRow <= rowEndIndex) {
+        if (fromRow === rowStartIndex)
+          newTransform = { ...transform, top: (transform.top || 0) - sheetTransform.from.rowOffset };
         else {
-          const u = this._skeletonManagerService.attachRangeWithCoord({ startRow: n, endRow: d - 1, startColumn: o.column, endColumn: a.column });
-          if (u == null)
+          const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startRow: rowStartIndex, endRow: fromRow - 1, startColumn: from.column, endColumn: to.column });
+          if (selectionCell == null)
             return;
-          c = { ...e, top: (e.top || 0) - u.endY + u.startY - i.from.rowOffset };
+          newTransform = { ...transform, top: (transform.top || 0) - selectionCell.endY + selectionCell.startY - sheetTransform.from.rowOffset };
         }
-        l = N(c, this._selectionRenderService);
-      } else if (h >= n && h <= t && r === O.Both) {
-        const u = this._skeletonManagerService.attachRangeWithCoord({ startColumn: o.column, endColumn: o.column, startRow: n - 1, endRow: n - 1 });
-        if (u == null)
+        newSheetTransform = transformToDrawingPosition(newTransform, this._selectionRenderService);
+      } else if (toRow >= rowStartIndex && toRow <= rowEndIndex && anchorType === SheetDrawingAnchorType.Both) {
+        const selectionCell = this._skeletonManagerService.attachRangeWithCoord({ startColumn: from.column, endColumn: from.column, startRow: rowStartIndex - 1, endRow: rowStartIndex - 1 });
+        if (selectionCell == null)
           return;
-        l = {
-          from: { ...o },
-          to: { ...a, row: n - 1, rowOffset: u.endY - u.startY }
-        }, c = $(l, this._selectionRenderService, this._skeletonManagerService);
+        newSheetTransform = {
+          from: { ...from },
+          to: { ...to, row: rowStartIndex - 1, rowOffset: selectionCell.endY - selectionCell.startY }
+        }, newTransform = drawingPositionToTransform(newSheetTransform, this._selectionRenderService, this._skeletonManagerService);
       }
     }
-    return l != null && c != null ? {
-      newSheetTransform: l,
-      newTransform: c
+    return newSheetTransform != null && newTransform != null ? {
+      newSheetTransform,
+      newTransform
     } : null;
   }
   _commandListener() {
     this.disposeWithMe(
-      this._commandService.onCommandExecuted((i) => {
-        i.id === sr.id && setTimeout(() => {
-          const e = i.params, { unitId: n, subUnitId: t } = e, r = this._drawingManagerService.drawingManagerData, s = [], o = [];
-          Object.keys(r).forEach((a) => {
-            const d = r[a];
-            Object.keys(d).forEach((h) => {
-              const l = d[h].data;
-              l != null && Object.keys(l).forEach((c) => {
-                if (a === n && h === t) {
-                  const u = l[c];
-                  u.transform = $(u.sheetTransform, this._selectionRenderService, this._skeletonManagerService), s.push(l[c]);
+      this._commandService.onCommandExecuted((command) => {
+        command.id === SetWorksheetActiveOperation.id && setTimeout(() => {
+          const params = command.params, { unitId: showUnitId, subUnitId: showSubunitId } = params, drawingMap = this._drawingManagerService.drawingManagerData, insertDrawings = [], removeDrawings = [];
+          Object.keys(drawingMap).forEach((unitId) => {
+            const subUnitMap = drawingMap[unitId];
+            Object.keys(subUnitMap).forEach((subUnitId) => {
+              const drawingData = subUnitMap[subUnitId].data;
+              drawingData != null && Object.keys(drawingData).forEach((drawingId) => {
+                if (unitId === showUnitId && subUnitId === showSubunitId) {
+                  const drawing = drawingData[drawingId];
+                  drawing.transform = drawingPositionToTransform(drawing.sheetTransform, this._selectionRenderService, this._skeletonManagerService), insertDrawings.push(drawingData[drawingId]);
                 } else
-                  o.push(l[c]);
+                  removeDrawings.push(drawingData[drawingId]);
               });
             });
-          }), this._drawingManagerService.removeNotification(o), this._drawingManagerService.addNotification(s);
+          }), this._drawingManagerService.removeNotification(removeDrawings), this._drawingManagerService.addNotification(insertDrawings);
         }, 0);
       })
     );
   }
   _sheetRefreshListener() {
     this.disposeWithMe(
-      this._commandService.onCommandExecuted((i) => {
-        di.includes(i.id) && requestIdleCallback(() => {
-          const e = i.params, { unitId: n, subUnitId: t, ranges: r } = e;
-          this._refreshDrawingTransform(n, t, r);
+      this._commandService.onCommandExecuted((command) => {
+        REFRESH_MUTATIONS.includes(command.id) && requestIdleCallback(() => {
+          const params = command.params, { unitId, subUnitId, ranges } = params;
+          this._refreshDrawingTransform(unitId, subUnitId, ranges);
         });
       })
     );
   }
-  _refreshDrawingTransform(i, e, n) {
-    const t = this._drawingManagerService.getDrawingData(i, e), r = [];
-    Object.keys(t).forEach((s) => {
-      const o = t[s], { sheetTransform: a, anchorType: d = O.Position } = o;
-      if (d === O.None)
+  _refreshDrawingTransform(unitId, subUnitId, ranges) {
+    const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId), updateDrawings = [];
+    Object.keys(drawingData).forEach((drawingId) => {
+      const drawing = drawingData[drawingId], { sheetTransform, anchorType = SheetDrawingAnchorType.Position } = drawing;
+      if (anchorType === SheetDrawingAnchorType.None)
         return !0;
-      const { from: h, to: l } = a, { row: c, column: u } = h, { row: g, column: f } = l;
-      for (let m = 0; m < n.length; m++) {
-        const p = n[m], { startRow: S, endRow: C, startColumn: v, endColumn: R } = p;
-        if (an.intersects(
+      const { from, to } = sheetTransform, { row: fromRow, column: fromColumn } = from, { row: toRow, column: toColumn } = to;
+      for (let i = 0; i < ranges.length; i++) {
+        const range = ranges[i], { startRow, endRow, startColumn, endColumn } = range;
+        if (Rectangle.intersects(
           {
-            startRow: S,
-            endRow: C,
-            startColumn: v,
-            endColumn: R
+            startRow,
+            endRow,
+            startColumn,
+            endColumn
           },
           {
-            startRow: c,
-            endRow: g,
-            startColumn: u,
-            endColumn: f
+            startRow: fromRow,
+            endRow: toRow,
+            startColumn: fromColumn,
+            endColumn: toColumn
           }
-        ) || c > C || u > R) {
-          r.push({
-            ...o,
-            transform: $(a, this._selectionRenderService, this._skeletonManagerService)
+        ) || fromRow > endRow || fromColumn > endColumn) {
+          updateDrawings.push({
+            ...drawing,
+            transform: drawingPositionToTransform(sheetTransform, this._selectionRenderService, this._skeletonManagerService)
           });
           break;
         }
       }
-    }), r.length !== 0 && (this._drawingManagerService.refreshTransform(r), this._commandService.syncExecuteCommand(j.id, [i]));
-  }
-};
-Ae = ai([
-  ie(se.Rendered, Ae),
-  ce(0, V),
-  ce(1, W(or)),
-  ce(2, K),
-  ce(3, k),
-  ce(4, z),
-  ce(5, he)
-], Ae);
-var li = Object.defineProperty, ui = Object.getOwnPropertyDescriptor, gi = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? ui(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && li(e, n, r), r;
-}, de = (i, e) => (n, t) => e(n, t, i);
-function hi(i, e, n, t) {
-  const { scaleX: r, scaleY: s } = e.getAncestorScale(), o = e.getViewport(Pn.VIEW_MAIN), a = {
+    }), updateDrawings.length !== 0 && (this._drawingManagerService.refreshTransform(updateDrawings), this._commandService.syncExecuteCommand(ClearSheetDrawingTransformerOperation.id, [unitId]));
+  }
+}, __name(_a4, "SheetDrawingTransformAffectedController"), _a4);
+SheetDrawingTransformAffectedController = __decorateClass$5([
+  __decorateParam$5(1, ICommandService),
+  __decorateParam$5(2, ISheetSelectionRenderService),
+  __decorateParam$5(3, Inject(SheetSkeletonManagerService)),
+  __decorateParam$5(4, Inject(SheetInterceptorService)),
+  __decorateParam$5(5, ISheetDrawingService),
+  __decorateParam$5(6, IDrawingManagerService),
+  __decorateParam$5(7, IUniverInstanceService)
+], SheetDrawingTransformAffectedController);
+var __defProp$4 = Object.defineProperty, __getOwnPropDesc$4 = Object.getOwnPropertyDescriptor, __decorateClass$4 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$4(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$4(target, key, result), result;
+}, "__decorateClass$4"), __decorateParam$4 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$4");
+function transformBound2DOMBound(originBound, scene, skeleton, worksheet) {
+  const { scaleX, scaleY } = scene.getAncestorScale(), viewMain = scene.getViewport(SHEET_VIEWPORT_KEY.VIEW_MAIN), absolute = {
     left: !0,
     top: !0
   };
-  if (!o)
+  if (!viewMain)
     return {
-      ...i,
-      absolute: a
+      ...originBound,
+      absolute
     };
-  const { left: d, right: h, top: l, bottom: c } = i, u = t.getFreeze(), { startColumn: g, startRow: f, xSplit: m, ySplit: p } = u, S = n.getNoMergeCellPositionByIndexWithNoHeader(f - p, g - m), C = n.getNoMergeCellPositionByIndexWithNoHeader(f, g), { rowHeaderWidth: v, columnHeaderHeight: R } = n, _ = C.startX - S.startX, b = C.startY - S.startY, { top: w, left: P, viewportScrollX: D, viewportScrollY: T } = o;
-  let U, M;
-  d < P ? (a.left = !0, U = (_ + v + (d - P)) * r, M = Math.max(
+  const { left, right, top, bottom } = originBound, freeze = worksheet.getFreeze(), { startColumn, startRow, xSplit, ySplit } = freeze, startSheetView = skeleton.getNoMergeCellPositionByIndexWithNoHeader(startRow - ySplit, startColumn - xSplit), endSheetView = skeleton.getNoMergeCellPositionByIndexWithNoHeader(startRow, startColumn), { rowHeaderWidth, columnHeaderHeight } = skeleton, freezeWidth = endSheetView.startX - startSheetView.startX, freezeHeight = endSheetView.startY - startSheetView.startY, { top: freezeTop, left: freezeLeft, viewportScrollX: actualScrollX, viewportScrollY: actualScrollY } = viewMain;
+  let offsetLeft, offsetRight;
+  left < freezeLeft ? (absolute.left = !0, offsetLeft = (freezeWidth + rowHeaderWidth + (left - freezeLeft)) * scaleX, offsetRight = Math.max(
     Math.min(
-      (_ + v + (h - P)) * r,
-      (_ + v) * r
+      (freezeWidth + rowHeaderWidth + (right - freezeLeft)) * scaleX,
+      (freezeWidth + rowHeaderWidth) * scaleX
     ),
-    (h - D) * r
-  )) : (a.left = !1, U = Math.max((d - D) * r, (_ + v) * r), M = Math.max((h - D) * r, (_ + v) * r));
-  let I, A;
-  return l < w ? (a.top = !0, I = (b + R + (l - w)) * s, A = Math.max(
+    (right - actualScrollX) * scaleX
+  )) : (absolute.left = !1, offsetLeft = Math.max((left - actualScrollX) * scaleX, (freezeWidth + rowHeaderWidth) * scaleX), offsetRight = Math.max((right - actualScrollX) * scaleX, (freezeWidth + rowHeaderWidth) * scaleX));
+  let offsetTop, offsetBottom;
+  return top < freezeTop ? (absolute.top = !0, offsetTop = (freezeHeight + columnHeaderHeight + (top - freezeTop)) * scaleY, offsetBottom = Math.max(
     Math.min(
-      (b + R + (h - w)) * s,
-      (b + R) * s
+      (freezeHeight + columnHeaderHeight + (right - freezeTop)) * scaleY,
+      (freezeHeight + columnHeaderHeight) * scaleY
     ),
-    (c - T) * s
-  )) : (a.top = !1, I = Math.max((l - T) * s, (b + R) * s), A = Math.max((c - T) * s, (b + R) * s)), {
-    left: U,
-    right: M,
-    top: I,
-    bottom: A,
-    absolute: a
+    (bottom - actualScrollY) * scaleY
+  )) : (absolute.top = !1, offsetTop = Math.max((top - actualScrollY) * scaleY, (freezeHeight + columnHeaderHeight) * scaleY), offsetBottom = Math.max((bottom - actualScrollY) * scaleY, (freezeHeight + columnHeaderHeight) * scaleY)), {
+    left: offsetLeft,
+    right: offsetRight,
+    top: offsetTop,
+    bottom: offsetBottom,
+    absolute
   };
 }
-const ze = (i, e, n, t) => {
-  const { scene: r } = e, { left: s, top: o, width: a, height: d, angle: h } = i, l = {
-    left: s,
-    right: s + a,
-    top: o,
-    bottom: o + d
-  }, c = hi(l, r, n, t);
+__name(transformBound2DOMBound, "transformBound2DOMBound");
+const calcPosition = /* @__PURE__ */ __name((targetObject, currentRender, skeleton, worksheet) => {
+  const { scene } = currentRender, { left, top, width, height, angle } = targetObject, bound = {
+    left,
+    right: left + width,
+    top,
+    bottom: top + height
+  }, offsetBound = transformBound2DOMBound(bound, scene, skeleton, worksheet);
   return {
-    startX: c.left,
-    endX: c.right,
-    startY: c.top,
-    endY: c.bottom,
-    rotate: h,
-    width: a,
-    height: d,
-    absolute: c.absolute
+    startX: offsetBound.left,
+    endX: offsetBound.right,
+    startY: offsetBound.top,
+    endY: offsetBound.bottom,
+    rotate: angle,
+    width,
+    height,
+    absolute: offsetBound.absolute
   };
-};
-let tt = class extends oe {
-  constructor(e, n, t, r, s, o) {
+}, "calcPosition");
+var _a5;
+let SheetCanvasFloatDomManagerService = (_a5 = class extends Disposable {
+  constructor(_renderManagerService, _univerInstanceService, _commandService, _drawingManagerService, _canvasFloatDomService, _sheetDrawingService) {
     super();
-    H(this, "_domLayerMap", /* @__PURE__ */ new Map());
-    H(this, "_domLayerInfoMap", /* @__PURE__ */ new Map());
-    H(this, "_transformChange$", new mt());
-    H(this, "transformChange$", this._transformChange$.asObservable());
-    H(this, "_remove$", new mt());
-    H(this, "remove$", this._remove$.asObservable());
-    H(this, "_hooks", []);
-    this._renderManagerService = e, this._univerInstanceService = n, this._commandService = t, this._drawingManagerService = r, this._canvasFloatDomService = s, this._sheetDrawingService = o, this._drawingAddListener(), this._scrollUpdateListener(), this._featureUpdateListener(), this._deleteListener();
-  }
-  _ensureMap(e, n) {
-    let t = this._domLayerMap.get(e);
-    t || (t = /* @__PURE__ */ new Map(), this._domLayerMap.set(e, t));
-    let r = t.get(n);
-    return r || (r = /* @__PURE__ */ new Map(), t.set(n, r)), r;
-  }
-  _getSceneAndTransformerByDrawingSearch(e) {
-    if (e == null)
+    __publicField(this, "_domLayerMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_domLayerInfoMap", /* @__PURE__ */ new Map());
+    __publicField(this, "_transformChange$", new Subject());
+    __publicField(this, "transformChange$", this._transformChange$.asObservable());
+    __publicField(this, "_remove$", new Subject());
+    __publicField(this, "remove$", this._remove$.asObservable());
+    __publicField(this, "_hooks", []);
+    this._renderManagerService = _renderManagerService, this._univerInstanceService = _univerInstanceService, this._commandService = _commandService, this._drawingManagerService = _drawingManagerService, this._canvasFloatDomService = _canvasFloatDomService, this._sheetDrawingService = _sheetDrawingService, this._drawingAddListener(), this._scrollUpdateListener(), this._featureUpdateListener(), this._deleteListener();
+  }
+  _ensureMap(unitId, subUnitId) {
+    let unitMap = this._domLayerMap.get(unitId);
+    unitMap || (unitMap = /* @__PURE__ */ new Map(), this._domLayerMap.set(unitId, unitMap));
+    let subUnitMap = unitMap.get(subUnitId);
+    return subUnitMap || (subUnitMap = /* @__PURE__ */ new Map(), unitMap.set(subUnitId, subUnitMap)), subUnitMap;
+  }
+  _getSceneAndTransformerByDrawingSearch(unitId) {
+    if (unitId == null)
       return;
-    const n = this._renderManagerService.getRenderById(e), t = n == null ? void 0 : n.scene;
-    if (n == null || t == null)
+    const renderObject = this._renderManagerService.getRenderById(unitId), scene = renderObject == null ? void 0 : renderObject.scene;
+    if (renderObject == null || scene == null)
       return null;
-    const r = t.getTransformerByCreate(), s = n.engine.getCanvasElement();
-    return { scene: t, transformer: r, renderObject: n, canvas: s };
+    const transformer = scene.getTransformerByCreate(), canvas = renderObject.engine.getCanvasElement();
+    return { scene, transformer, renderObject, canvas };
   }
-  _getFloatDomProps(e) {
-    let n;
-    return this._hooks.forEach((t) => {
-      n = t.onGetFloatDomProps(e);
-    }), n;
+  _getFloatDomProps(id) {
+    let props;
+    return this._hooks.forEach((hook) => {
+      props = hook.onGetFloatDomProps(id);
+    }), props;
   }
   // eslint-disable-next-line max-lines-per-function
   _drawingAddListener() {
     this.disposeWithMe(
       // eslint-disable-next-line max-lines-per-function
-      this._drawingManagerService.add$.subscribe((e) => {
-        e.forEach((n) => {
-          var ot, at, ct;
-          const { unitId: t, subUnitId: r, drawingId: s } = n, o = le(this._univerInstanceService, { unitId: t, subUnitId: r }), a = this._drawingManagerService.getDrawingByParam(n), d = (ot = this._renderManagerService.getRenderById(t)) == null ? void 0 : ot.with(re).getWorksheetSkeleton(r);
-          if (a == null || o == null || d == null)
+      this._drawingManagerService.add$.subscribe((params) => {
+        params.forEach((param) => {
+          var _a10, _b, _c;
+          const { unitId, subUnitId, drawingId } = param, target = getSheetCommandTarget(this._univerInstanceService, { unitId, subUnitId }), floatDomParam = this._drawingManagerService.getDrawingByParam(param), skeleton = (_a10 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a10.with(SheetSkeletonManagerService).getWorksheetSkeleton(subUnitId);
+          if (floatDomParam == null || target == null || skeleton == null)
             return;
-          const { transform: h, drawingType: l } = a;
-          if (l !== Ye.DRAWING_DOM)
+          const { transform, drawingType, data } = floatDomParam;
+          if (drawingType !== DrawingTypeEnum$1.DRAWING_DOM)
             return;
-          const c = this._getSceneAndTransformerByDrawingSearch(t);
-          if (c == null)
+          const renderObject = this._getSceneAndTransformerByDrawingSearch(unitId);
+          if (renderObject == null)
             return;
-          const { scene: u, canvas: g } = c;
-          if (h == null)
+          const { scene, canvas } = renderObject;
+          if (transform == null)
             return !0;
-          const { left: f, top: m, width: p, height: S, angle: C, flipX: v, flipY: R, skewX: _, skewY: b } = h, w = Mn({ unitId: t, subUnitId: r, drawingId: s }), P = u.getObject(w);
-          if (P != null) {
-            P.transformByState({ left: f, top: m, width: p, height: S, angle: C, flipX: v, flipY: R, skewX: _, skewY: b });
+          const { left, top, width, height, angle, flipX, flipY, skewX, skewY } = transform, rectShapeKey = getDrawingShapeKeyByDrawingSearch({ unitId, subUnitId, drawingId }), rectShape = scene.getObject(rectShapeKey);
+          if (rectShape != null) {
+            rectShape.transformByState({ left, top, width, height, angle, flipX, flipY, skewX, skewY });
             return;
           }
-          const D = {
-            left: f,
-            top: m,
-            width: p,
-            height: S,
-            zIndex: this._drawingManagerService.getDrawingOrder(t, r).length - 1
-          }, T = new yn(w, D);
-          u.addObject(T, On).attachTransformerTo(T);
-          const U = this._ensureMap(t, r), M = new cn(), I = ze(T, c.renderObject, d.skeleton, o.worksheet), A = new $n(I), G = {
-            dispose: M,
-            rect: T,
-            position$: A,
-            unitId: t,
-            subUnitId: r
+          const imageConfig = {
+            left,
+            top,
+            width,
+            height,
+            zIndex: this._drawingManagerService.getDrawingOrder(unitId, subUnitId).length - 1
+          }, rect = new Rect(rectShapeKey, imageConfig);
+          scene.addObject(rect, DRAWING_OBJECT_LAYER_INDEX).attachTransformerTo(rect);
+          const map2 = this._ensureMap(unitId, subUnitId), disposableCollection = new DisposableCollection(), initPosition = calcPosition(rect, renderObject.renderObject, skeleton.skeleton, target.worksheet), position$ = new BehaviorSubject(initPosition), info = {
+            dispose: disposableCollection,
+            rect,
+            position$,
+            unitId,
+            subUnitId
           };
           this._canvasFloatDomService.addFloatDom({
-            position$: A,
-            id: s,
-            componentKey: a.componentKey,
-            onPointerDown: (x) => {
-              g.dispatchEvent(new PointerEvent(x.type, x));
-            },
-            onPointerMove: (x) => {
-              g.dispatchEvent(new PointerEvent(x.type, x));
-            },
-            onPointerUp: (x) => {
-              g.dispatchEvent(new PointerEvent(x.type, x));
-            },
-            onWheel: (x) => {
-              g.dispatchEvent(new WheelEvent(x.type, x));
-            },
-            props: (ct = (at = U.get(s)) == null ? void 0 : at.props) != null ? ct : this._getFloatDomProps(s)
+            position$,
+            id: drawingId,
+            componentKey: floatDomParam.componentKey,
+            onPointerDown: /* @__PURE__ */ __name((evt) => {
+              canvas.dispatchEvent(new PointerEvent(evt.type, evt));
+            }, "onPointerDown"),
+            onPointerMove: /* @__PURE__ */ __name((evt) => {
+              canvas.dispatchEvent(new PointerEvent(evt.type, evt));
+            }, "onPointerMove"),
+            onPointerUp: /* @__PURE__ */ __name((evt) => {
+              canvas.dispatchEvent(new PointerEvent(evt.type, evt));
+            }, "onPointerUp"),
+            onWheel: /* @__PURE__ */ __name((evt) => {
+              canvas.dispatchEvent(new WheelEvent(evt.type, evt));
+            }, "onWheel"),
+            props: (_c = (_b = map2.get(drawingId)) == null ? void 0 : _b.props) != null ? _c : this._getFloatDomProps(drawingId),
+            data
           });
-          const J = T.onTransformChange$.subscribeEvent(() => {
-            const x = ze(T, c.renderObject, d.skeleton, o.worksheet);
-            A.next(
-              x
+          const listener = rect.onTransformChange$.subscribeEvent(() => {
+            const newPosition = calcPosition(rect, renderObject.renderObject, skeleton.skeleton, target.worksheet);
+            position$.next(
+              newPosition
             );
           });
-          M.add(() => {
-            this._canvasFloatDomService.removeFloatDom(s);
-          }), J && M.add(J), this._domLayerInfoMap.set(s, G);
+          disposableCollection.add(() => {
+            this._canvasFloatDomService.removeFloatDom(drawingId);
+          }), listener && disposableCollection.add(listener), this._domLayerInfoMap.set(drawingId, info), map2.set(drawingId, {
+            ...map2.get(drawingId)
+          });
         });
       })
     );
   }
   _scrollUpdateListener() {
-    this.disposeWithMe(this._commandService.onCommandExecuted((e) => {
-      var t, r;
-      const n = (s, o) => {
-        var u;
-        const a = this._getSceneAndTransformerByDrawingSearch(s), d = this._ensureMap(s, o), h = Array.from(d.keys()), l = le(this._univerInstanceService, { unitId: s, subUnitId: o }), c = (u = this._renderManagerService.getRenderById(s)) == null ? void 0 : u.with(re).getWorksheetSkeleton(o);
-        !a || !l || !c || h.forEach((g) => {
-          const f = this._domLayerInfoMap.get(g);
-          if (f) {
-            const m = ze(f.rect, a.renderObject, c.skeleton, l.worksheet);
-            f.position$.next(m);
+    this.disposeWithMe(this._commandService.onCommandExecuted((commandInfo) => {
+      var _a10, _b;
+      const updateSheet = /* @__PURE__ */ __name((unitId, subUnitId) => {
+        var _a11;
+        const renderObject = this._getSceneAndTransformerByDrawingSearch(unitId), map2 = this._ensureMap(unitId, subUnitId), ids = Array.from(map2.keys()), target = getSheetCommandTarget(this._univerInstanceService, { unitId, subUnitId }), skeleton = (_a11 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a11.with(SheetSkeletonManagerService).getWorksheetSkeleton(subUnitId);
+        !renderObject || !target || !skeleton || ids.forEach((id) => {
+          const info = this._domLayerInfoMap.get(id);
+          if (info) {
+            const position = calcPosition(info.rect, renderObject.renderObject, skeleton.skeleton, target.worksheet);
+            info.position$.next(position);
           }
         });
-      };
-      if (e.id === Nn.id) {
-        const s = e.params, { unitId: o, sheetId: a } = s;
-        n(o, a);
-      } else if (e.id === jn.id) {
-        const s = e.params, { unitId: o } = s;
-        Array.from((r = (t = this._domLayerMap.get(o)) == null ? void 0 : t.keys()) != null ? r : []).forEach((d) => {
-          n(o, d);
+      }, "updateSheet");
+      if (commandInfo.id === SetScrollOperation.id) {
+        const params = commandInfo.params, { unitId, sheetId } = params;
+        updateSheet(unitId, sheetId);
+      } else if (commandInfo.id === SetZoomRatioOperation.id) {
+        const params = commandInfo.params, { unitId } = params;
+        Array.from((_b = (_a10 = this._domLayerMap.get(unitId)) == null ? void 0 : _a10.keys()) != null ? _b : []).forEach((subUnitId) => {
+          updateSheet(unitId, subUnitId);
         });
-      } else if (e.id === ar.id) {
-        const { unitId: s, subUnitId: o } = e.params;
-        n(s, o);
+      } else if (commandInfo.id === SetFrozenMutation.id) {
+        const { unitId, subUnitId } = commandInfo.params;
+        updateSheet(unitId, subUnitId);
       }
     }));
   }
-  _getPosition(e, n) {
-    var u;
-    const { startX: t, endX: r, startY: s, endY: o } = e, a = (u = this._renderManagerService.getRenderById(n)) == null ? void 0 : u.with(Ge);
-    if (a == null)
+  _getPosition(position, unitId) {
+    var _a10;
+    const { startX, endX, startY, endY } = position, selectionRenderService = (_a10 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a10.with(ISheetSelectionRenderService);
+    if (selectionRenderService == null)
       return;
-    const d = a.getSelectionCellByPosition(t, s);
-    if (d == null)
+    const start = selectionRenderService.getSelectionCellByPosition(startX, startY);
+    if (start == null)
       return;
-    const h = {
-      column: d.actualColumn,
-      columnOffset: t - d.startX,
-      row: d.actualRow,
-      rowOffset: s - d.startY
-    }, l = a.getSelectionCellByPosition(r, o);
-    if (l == null)
+    const from = {
+      column: start.actualColumn,
+      columnOffset: startX - start.startX,
+      row: start.actualRow,
+      rowOffset: startY - start.startY
+    }, end = selectionRenderService.getSelectionCellByPosition(endX, endY);
+    if (end == null)
       return;
-    const c = {
-      column: l.actualColumn,
-      columnOffset: r - l.startX,
-      row: l.actualRow,
-      rowOffset: o - l.startY
+    const to = {
+      column: end.actualColumn,
+      columnOffset: endX - end.startX,
+      row: end.actualRow,
+      rowOffset: endY - end.startY
     };
     return {
-      from: h,
-      to: c
+      from,
+      to
     };
   }
   _featureUpdateListener() {
     this.disposeWithMe(
-      this._drawingManagerService.update$.subscribe((e) => {
-        e.forEach((n) => {
-          const t = this._drawingManagerService.getDrawingByParam(n);
-          if (!t || t.drawingType !== Ye.DRAWING_DOM)
+      this._drawingManagerService.update$.subscribe((params) => {
+        params.forEach((data) => {
+          const sheetDrawing = this._drawingManagerService.getDrawingByParam(data);
+          if (!sheetDrawing || sheetDrawing.drawingType !== DrawingTypeEnum$1.DRAWING_DOM)
             return;
-          const r = {
-            ...t.transform
+          const newValue = {
+            ...sheetDrawing.transform
           };
-          this._transformChange$.next({ id: n.drawingId, value: r });
+          this._transformChange$.next({ id: data.drawingId, value: newValue });
         });
       })
     );
   }
   _deleteListener() {
     this.disposeWithMe(
-      this._drawingManagerService.remove$.subscribe((e) => {
-        e.forEach((n) => {
-          this._removeDom(n.drawingId);
+      this._drawingManagerService.remove$.subscribe((params) => {
+        params.forEach((param) => {
+          this._removeDom(param.drawingId);
         });
       })
     );
   }
-  addFloatDomToPosition(e) {
-    const n = le(this._univerInstanceService, {
-      unitId: e.unitId,
-      subUnitId: e.subUnitId
+  addFloatDomToPosition(layer) {
+    const target = getSheetCommandTarget(this._univerInstanceService, {
+      unitId: layer.unitId,
+      subUnitId: layer.subUnitId
     });
-    if (!n)
+    if (!target)
       throw new Error("cannot find current target!");
-    const { unitId: t, subUnitId: r } = n, { initPosition: s, componentKey: o } = e, a = ne.generateRandomId(), d = this._getPosition(s, t);
-    if (d == null)
+    const { unitId, subUnitId } = target, { initPosition, componentKey, data } = layer, id = Tools.generateRandomId(), sheetTransform = this._getPosition(initPosition, unitId);
+    if (sheetTransform == null)
       return;
-    this._ensureMap(t, r).set(a, e);
-    const l = {
-      unitId: t,
-      subUnitId: r,
-      drawingId: a,
-      drawingType: Ye.DRAWING_DOM,
-      componentKey: o,
-      sheetTransform: d,
+    this._ensureMap(unitId, subUnitId).set(id, layer);
+    const sheetDrawingParam = {
+      unitId,
+      subUnitId,
+      drawingId: id,
+      drawingType: DrawingTypeEnum$1.DRAWING_DOM,
+      componentKey,
+      sheetTransform,
       transform: {
-        left: s.startX,
-        top: s.startY,
-        width: s.endX - s.startX,
-        height: s.endY - s.startY
-      }
+        left: initPosition.startX,
+        top: initPosition.startY,
+        width: initPosition.endX - initPosition.startX,
+        height: initPosition.endY - initPosition.startY
+      },
+      data
     };
-    return this._commandService.executeCommand(st.id, {
-      unitId: t,
-      drawings: [l]
+    return this._commandService.executeCommand(InsertSheetDrawingCommand.id, {
+      unitId,
+      drawings: [sheetDrawingParam]
     }), {
-      id: a,
-      dispose: () => {
-        this._removeDom(a, !0);
-      }
+      id,
+      dispose: /* @__PURE__ */ __name(() => {
+        this._removeDom(id, !0);
+      }, "dispose")
     };
   }
-  _removeDom(e, n = !1) {
-    const t = this._domLayerInfoMap.get(e);
-    if (!t)
+  _removeDom(id, removeDrawing = !1) {
+    const info = this._domLayerInfoMap.get(id);
+    if (!info)
       return;
-    const { unitId: r, subUnitId: s } = t;
-    this._domLayerInfoMap.delete(e), t.dispose.dispose();
-    const o = this._getSceneAndTransformerByDrawingSearch(r);
-    if (o && o.scene.removeObject(t.rect), n) {
-      this._ensureMap(r, s).delete(e);
-      const d = this._drawingManagerService.getDrawingByParam({ unitId: r, subUnitId: s, drawingId: e });
-      if (!d)
+    const { unitId, subUnitId } = info;
+    this._domLayerInfoMap.delete(id), info.dispose.dispose();
+    const renderObject = this._getSceneAndTransformerByDrawingSearch(unitId);
+    if (renderObject && renderObject.scene.removeObject(info.rect), removeDrawing) {
+      this._ensureMap(unitId, subUnitId).delete(id);
+      const param = this._drawingManagerService.getDrawingByParam({ unitId, subUnitId, drawingId: id });
+      if (!param)
         return;
-      const h = this._sheetDrawingService.getBatchRemoveOp([d]), { redo: l, objects: c } = h;
-      this._commandService.syncExecuteCommand(E.id, { unitId: r, subUnitId: s, op: l, objects: c, type: y.REMOVE });
+      const jsonOp = this._sheetDrawingService.getBatchRemoveOp([param]), { redo, objects } = jsonOp;
+      this._commandService.syncExecuteCommand(SetDrawingApplyMutation.id, { unitId, subUnitId, op: redo, objects, type: DrawingApplyType.REMOVE });
     }
   }
-  addHook(e) {
-    return this._hooks.push(e), {
-      dispose: () => {
-        const n = this._hooks.findIndex((t) => t === e);
-        this._hooks.splice(n, 1);
-      }
+  addHook(hook) {
+    return this._hooks.push(hook), {
+      dispose: /* @__PURE__ */ __name(() => {
+        const index = this._hooks.findIndex((h) => h === hook);
+        this._hooks.splice(index, 1);
+      }, "dispose")
     };
   }
-};
-tt = gi([
-  de(0, W(K)),
-  de(1, he),
-  de(2, W(V)),
-  de(3, z),
-  de(4, W(Kn)),
-  de(5, k)
-], tt);
-var mi = Object.defineProperty, fi = Object.getOwnPropertyDescriptor, pi = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? fi(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && mi(e, n, r), r;
-}, Oe = (i, e) => (n, t) => e(n, t, i);
-let Ne = class extends oe {
-  constructor(i, e, n, t) {
-    super(), this._sheetPrintInterceptorService = i, this._drawingRenderService = e, this._drawingManagerService = n, this._renderManagerService = t, this._initPrinting();
+}, __name(_a5, "SheetCanvasFloatDomManagerService"), _a5);
+SheetCanvasFloatDomManagerService = __decorateClass$4([
+  OnLifecycle(LifecycleStages.Starting, SheetCanvasFloatDomManagerService),
+  __decorateParam$4(0, Inject(IRenderManagerService)),
+  __decorateParam$4(1, IUniverInstanceService),
+  __decorateParam$4(2, Inject(ICommandService)),
+  __decorateParam$4(3, IDrawingManagerService),
+  __decorateParam$4(4, Inject(CanvasFloatDomService)),
+  __decorateParam$4(5, ISheetDrawingService)
+], SheetCanvasFloatDomManagerService);
+var __defProp$3 = Object.defineProperty, __getOwnPropDesc$3 = Object.getOwnPropertyDescriptor, __decorateClass$3 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$3(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$3(target, key, result), result;
+}, "__decorateClass$3"), __decorateParam$3 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$3"), _a6;
+let SheetDrawingPrintingController = (_a6 = class extends Disposable {
+  constructor(_sheetPrintInterceptorService, _drawingRenderService, _drawingManagerService, _renderManagerService) {
+    super(), this._sheetPrintInterceptorService = _sheetPrintInterceptorService, this._drawingRenderService = _drawingRenderService, this._drawingManagerService = _drawingManagerService, this._renderManagerService = _renderManagerService, this._initPrinting();
   }
   _initPrinting() {
     this.disposeWithMe(
       this._sheetPrintInterceptorService.interceptor.intercept(
         this._sheetPrintInterceptorService.interceptor.getInterceptPoints().PRINTING_COMPONENT_COLLECT,
         {
-          handler: (i, e, n) => {
-            const { unitId: t, scene: r, subUnitId: s } = e, o = this._drawingManagerService.getDrawingDataForUnit(t), a = o == null ? void 0 : o[s];
-            return a && a.order.forEach((d) => {
-              this._drawingRenderService.renderDrawing(a.data[d], r);
-            }), n();
-          }
+          handler: /* @__PURE__ */ __name((_param, pos, next) => {
+            const { unitId, scene, subUnitId } = pos, unitData = this._drawingManagerService.getDrawingDataForUnit(unitId), subUnitData = unitData == null ? void 0 : unitData[subUnitId];
+            return subUnitData && subUnitData.order.forEach((id) => {
+              this._drawingRenderService.renderDrawing(subUnitData.data[id], scene);
+            }), next();
+          }, "handler")
         }
       )
     ), this.disposeWithMe(
       this._sheetPrintInterceptorService.interceptor.intercept(
         this._sheetPrintInterceptorService.interceptor.getInterceptPoints().PRINTING_RANGE,
         {
-          handler: (i, e, n) => {
-            const { unitId: t, subUnitId: r } = e, s = this._renderManagerService.getRenderById(t);
-            if (!s)
-              return n(i);
-            const o = s.with(re).getWorksheetSkeleton(r);
-            if (!o)
-              return n(i);
-            const a = this._drawingManagerService.getDrawingDataForUnit(t), d = a == null ? void 0 : a[e.subUnitId];
-            if (!d)
-              return n(i);
-            const { scaleX: h, scaleY: l } = s.scene, c = i ? { ...i } : { startColumn: 0, endColumn: 0, endRow: 0, startRow: 0 }, u = d.order.map((g) => d.data[g]).filter((g) => g.drawingType !== Ve.DRAWING_DOM);
-            return u.length ? (u.forEach((g) => {
-              if (!g.groupId && g.transform && ne.isDefine(g.transform.left) && ne.isDefine(g.transform.top) && ne.isDefine(g.transform.width) && ne.isDefine(g.transform.height)) {
-                const f = o.skeleton.getCellPositionByOffset(g.transform.left, g.transform.top, h, l, { x: 0, y: 0 }), m = o.skeleton.getCellPositionByOffset(g.transform.left + g.transform.width, g.transform.top + g.transform.height, h, l, { x: 0, y: 0 });
-                f.column < c.startColumn && (c.startColumn = f.column), f.row < c.startRow && (c.startRow = f.row), c.endRow < m.row && (c.endRow = m.row), c.endColumn < m.column && (c.endColumn = m.column);
+          handler: /* @__PURE__ */ __name((range, pos, next) => {
+            const { unitId, subUnitId } = pos, renderer = this._renderManagerService.getRenderById(unitId);
+            if (!renderer)
+              return next(range);
+            const skeleton = renderer.with(SheetSkeletonManagerService).getWorksheetSkeleton(subUnitId);
+            if (!skeleton)
+              return next(range);
+            const unitData = this._drawingManagerService.getDrawingDataForUnit(unitId), subUnitData = unitData == null ? void 0 : unitData[pos.subUnitId];
+            if (!subUnitData)
+              return next(range);
+            const { scaleX, scaleY } = renderer.scene, newRange = range ? { ...range } : { startColumn: 0, endColumn: 0, endRow: 0, startRow: 0 }, data = subUnitData.order.map((key) => subUnitData.data[key]).filter((item) => item.drawingType !== DrawingTypeEnum.DRAWING_DOM);
+            return data.length ? (data.forEach((param) => {
+              if (!param.groupId && param.transform && Tools.isDefine(param.transform.left) && Tools.isDefine(param.transform.top) && Tools.isDefine(param.transform.width) && Tools.isDefine(param.transform.height)) {
+                const start = skeleton.skeleton.getCellPositionByOffset(param.transform.left, param.transform.top, scaleX, scaleY, { x: 0, y: 0 }), end = skeleton.skeleton.getCellPositionByOffset(param.transform.left + param.transform.width, param.transform.top + param.transform.height, scaleX, scaleY, { x: 0, y: 0 });
+                start.column < newRange.startColumn && (newRange.startColumn = start.column), start.row < newRange.startRow && (newRange.startRow = start.row), newRange.endRow < end.row && (newRange.endRow = end.row), newRange.endColumn < end.column && (newRange.endColumn = end.column);
               }
-            }), n(c)) : n(i);
-          }
+            }), next(newRange)) : next(range);
+          }, "handler")
         }
       )
     );
   }
-};
-Ne = pi([
-  ie(se.Rendered, Ne),
-  Oe(0, W(Ln)),
-  Oe(1, W(_n)),
-  Oe(2, z),
-  Oe(3, K)
-], Ne);
-var wi = Object.defineProperty, _i = Object.getOwnPropertyDescriptor, vi = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? _i(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && wi(e, n, r), r;
-}, fe = (i, e) => (n, t) => e(n, t, i);
-let je = class extends oe {
-  constructor(i, e, n, t, r) {
-    super(), this._drawingManagerService = i, this._renderManagerService = e, this._permissionService = n, this._univerInstanceService = t, this._userManagerService = r, this._initDrawingVisible(), this._initDrawingEditable(), this._initViewPermissionChange(), this._initEditPermissionChange();
+}, __name(_a6, "SheetDrawingPrintingController"), _a6);
+SheetDrawingPrintingController = __decorateClass$3([
+  OnLifecycle(LifecycleStages.Rendered, SheetDrawingPrintingController),
+  __decorateParam$3(0, Inject(SheetPrintInterceptorService)),
+  __decorateParam$3(1, Inject(DrawingRenderService)),
+  __decorateParam$3(2, IDrawingManagerService),
+  __decorateParam$3(3, IRenderManagerService)
+], SheetDrawingPrintingController);
+var __defProp$2 = Object.defineProperty, __getOwnPropDesc$2 = Object.getOwnPropertyDescriptor, __decorateClass$2 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$2(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$2(target, key, result), result;
+}, "__decorateClass$2"), __decorateParam$2 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$2"), _a7;
+let SheetDrawingPermissionController = (_a7 = class extends Disposable {
+  constructor(_drawingManagerService, _renderManagerService, _permissionService, _univerInstanceService, _userManagerService) {
+    super(), this._drawingManagerService = _drawingManagerService, this._renderManagerService = _renderManagerService, this._permissionService = _permissionService, this._univerInstanceService = _univerInstanceService, this._userManagerService = _userManagerService, this._initDrawingVisible(), this._initDrawingEditable(), this._initViewPermissionChange(), this._initEditPermissionChange();
   }
   _initDrawingVisible() {
-    const i = this._univerInstanceService.getCurrentTypeOfUnit$(B.UNIVER_SHEET);
+    const workbook$ = this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_SHEET);
     this.disposeWithMe(
-      Re([i, this._userManagerService.currentUser$]).subscribe(([e, n]) => {
-        if (!e) {
+      combineLatest([workbook$, this._userManagerService.currentUser$]).subscribe(([workbook, _]) => {
+        if (!workbook) {
           this._drawingManagerService.setDrawingVisible(!1);
           return;
         }
-        e.activeSheet$.subscribe((t) => {
-          if (!t) {
+        workbook.activeSheet$.subscribe((sheet) => {
+          if (!sheet) {
             this._drawingManagerService.setDrawingVisible(!1);
             return;
           }
-          const r = e.getUnitId(), s = t.getSheetId();
-          if (this._permissionService.composePermission([new pt(r).id, new He(r, s).id]).every((a) => a.value))
+          const unitId = workbook.getUnitId(), subUnitId = sheet.getSheetId();
+          if (this._permissionService.composePermission([new WorkbookViewPermission(unitId).id, new WorksheetViewPermission(unitId, subUnitId).id]).every((permission) => permission.value))
             this._drawingManagerService.setDrawingVisible(!0);
           else {
             this._drawingManagerService.setDrawingVisible(!1);
-            const a = e.getUnitId(), d = t.getSheetId(), h = this._drawingManagerService.getDrawingData(a, d), l = Object.values(h), c = this._renderManagerService.getRenderById(a), u = c == null ? void 0 : c.scene;
-            if (u == null)
+            const unitId2 = workbook.getUnitId(), subUnitId2 = sheet.getSheetId(), drawingData = this._drawingManagerService.getDrawingData(unitId2, subUnitId2), drawingDataValues = Object.values(drawingData), renderObject = this._renderManagerService.getRenderById(unitId2), scene = renderObject == null ? void 0 : renderObject.scene;
+            if (scene == null)
               return;
-            u.getAllObjects().forEach((f) => {
-              f.classType === ae.IMAGE && l.some((m) => f.oKey.includes(m.drawingId)) && u.removeObject(f);
+            scene.getAllObjects().forEach((object) => {
+              object.classType === RENDER_CLASS_TYPE.IMAGE && drawingDataValues.some((item) => object.oKey.includes(item.drawingId)) && scene.removeObject(object);
             });
           }
         });
@@ -2174,28 +2156,28 @@ let je = class extends oe {
     );
   }
   _initDrawingEditable() {
-    const i = this._univerInstanceService.getCurrentTypeOfUnit$(B.UNIVER_SHEET);
+    const workbook$ = this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_SHEET);
     this.disposeWithMe(
-      Re([i, this._userManagerService.currentUser$]).subscribe(([e, n]) => {
-        if (!e) {
+      combineLatest([workbook$, this._userManagerService.currentUser$]).subscribe(([workbook, _]) => {
+        if (!workbook) {
           this._drawingManagerService.setDrawingEditable(!1);
           return;
         }
-        e.activeSheet$.subscribe((t) => {
-          if (!t) {
+        workbook.activeSheet$.subscribe((sheet) => {
+          if (!sheet) {
             this._drawingManagerService.setDrawingEditable(!1);
             return;
           }
-          const r = e.getUnitId(), s = t.getSheetId();
-          if (this._permissionService.composePermission([new Ze(r).id, new Pe(r, s).id]).every((a) => a.value))
+          const unitId = workbook.getUnitId(), subUnitId = sheet.getSheetId();
+          if (this._permissionService.composePermission([new WorkbookEditablePermission(unitId).id, new WorksheetEditPermission(unitId, subUnitId).id]).every((permission) => permission.value))
             this._drawingManagerService.setDrawingEditable(!0);
           else {
             this._drawingManagerService.setDrawingEditable(!1);
-            const a = e.getUnitId(), d = t.getSheetId(), h = this._drawingManagerService.getDrawingData(a, d), l = Object.values(h), c = this._renderManagerService.getRenderById(a), u = c == null ? void 0 : c.scene;
-            if (u == null)
+            const unitId2 = workbook.getUnitId(), subUnitId2 = sheet.getSheetId(), drawingData = this._drawingManagerService.getDrawingData(unitId2, subUnitId2), drawingDataValues = Object.values(drawingData), renderObject = this._renderManagerService.getRenderById(unitId2), scene = renderObject == null ? void 0 : renderObject.scene;
+            if (scene == null)
               return;
-            u.getAllObjects().forEach((f) => {
-              f.classType === ae.IMAGE && l.some((m) => f.oKey.includes(m.drawingId)) && u.detachTransformerFrom(f);
+            scene.getAllObjects().forEach((object) => {
+              object.classType === RENDER_CLASS_TYPE.IMAGE && drawingDataValues.some((item) => object.oKey.includes(item.drawingId)) && scene.detachTransformerFrom(object);
             });
           }
         });
@@ -2203,303 +2185,297 @@ let je = class extends oe {
     );
   }
   _initViewPermissionChange() {
-    const i = this._univerInstanceService.getCurrentTypeOfUnit$(B.UNIVER_SHEET);
+    const workbook$ = this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_SHEET);
     this.disposeWithMe(
-      Re([i, this._userManagerService.currentUser$]).subscribe(([e, n]) => {
-        e && e.activeSheet$.subscribe((t) => {
-          var c;
-          if (!t)
+      combineLatest([workbook$, this._userManagerService.currentUser$]).subscribe(([workbook, _]) => {
+        workbook && workbook.activeSheet$.subscribe((sheet) => {
+          var _a10;
+          if (!sheet)
             return;
-          const r = e.getUnitId(), s = t.getSheetId();
-          let o = !0;
-          const a = this._renderManagerService.getRenderById(r), d = a == null ? void 0 : a.scene;
-          if (d == null)
+          const unitId = workbook.getUnitId(), subUnitId = sheet.getSheetId();
+          let initialViewPermission = !0;
+          const renderObject = this._renderManagerService.getRenderById(unitId), scene = renderObject == null ? void 0 : renderObject.scene;
+          if (scene == null)
             return;
-          const h = d.getTransformerByCreate(), l = this._permissionService.composePermission$([new pt(r).id, new He(r, s).id]).pipe(ft((u) => u.every((g) => g.value)));
-          l == null || l.pipe(
-            Me((u) => u !== o),
-            De()
+          const transformer = scene.getTransformerByCreate(), worksheetViewPermission$ = this._permissionService.composePermission$([new WorkbookViewPermission(unitId).id, new WorksheetViewPermission(unitId, subUnitId).id]).pipe(map((permissions) => permissions.every((item) => item.value)));
+          worksheetViewPermission$ == null || worksheetViewPermission$.pipe(
+            filter((permission) => permission !== initialViewPermission),
+            distinctUntilChanged()
           ).subscribe({
-            next: (u) => {
-              o = u, this._drawingManagerService.setDrawingVisible(u);
-              const g = d.getAllObjects(), f = this._drawingManagerService.getDrawingData(r, s), m = Object.values(f);
-              u ? this._drawingManagerService.addNotification(m) : (g.forEach((p) => {
-                p.classType === ae.IMAGE && m.some((S) => p.oKey.includes(S.drawingId)) && d.removeObject(p);
-              }), h.clearSelectedObjects());
-            }
-          }), (c = this._permissionService.getPermissionPoint$(new He(r, s).id)) == null || c.pipe(
-            Me((u) => u.value !== o),
-            De()
+            next: /* @__PURE__ */ __name((permission) => {
+              initialViewPermission = permission, this._drawingManagerService.setDrawingVisible(permission);
+              const objects = scene.getAllObjects(), drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId), drawingDataValues = Object.values(drawingData);
+              permission ? this._drawingManagerService.addNotification(drawingDataValues) : (objects.forEach((object) => {
+                object.classType === RENDER_CLASS_TYPE.IMAGE && drawingDataValues.some((item) => object.oKey.includes(item.drawingId)) && scene.removeObject(object);
+              }), transformer.clearSelectedObjects());
+            }, "next")
+          }), (_a10 = this._permissionService.getPermissionPoint$(new WorksheetViewPermission(unitId, subUnitId).id)) == null || _a10.pipe(
+            filter((permission) => permission.value !== initialViewPermission),
+            distinctUntilChanged()
           ).subscribe({
-            complete: () => {
-              o = !0, this._drawingManagerService.setDrawingVisible(!0);
-              const u = this._drawingManagerService.getDrawingData(r, s), g = Object.values(u);
-              this._drawingManagerService.addNotification(g);
-            }
+            complete: /* @__PURE__ */ __name(() => {
+              initialViewPermission = !0, this._drawingManagerService.setDrawingVisible(!0);
+              const drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId), drawingDataValues = Object.values(drawingData);
+              this._drawingManagerService.addNotification(drawingDataValues);
+            }, "complete")
           });
         });
       })
     );
   }
   _initEditPermissionChange() {
-    const i = this._univerInstanceService.getCurrentTypeOfUnit$(B.UNIVER_SHEET);
+    const workbook$ = this._univerInstanceService.getCurrentTypeOfUnit$(UniverInstanceType.UNIVER_SHEET);
     this.disposeWithMe(
-      Re([i, this._userManagerService.currentUser$]).subscribe(([e, n]) => {
-        e && e.activeSheet$.subscribe((t) => {
-          var c;
-          if (!t)
+      combineLatest([workbook$, this._userManagerService.currentUser$]).subscribe(([workbook, _]) => {
+        workbook && workbook.activeSheet$.subscribe((sheet) => {
+          var _a10;
+          if (!sheet)
             return;
-          const r = e.getUnitId(), s = t.getSheetId();
-          let o = !0;
-          const a = this._renderManagerService.getRenderById(r), d = a == null ? void 0 : a.scene;
-          if (d == null)
+          const unitId = workbook.getUnitId(), subUnitId = sheet.getSheetId();
+          let initialEditPermission = !0;
+          const renderObject = this._renderManagerService.getRenderById(unitId), scene = renderObject == null ? void 0 : renderObject.scene;
+          if (scene == null)
             return;
-          const h = d.getTransformerByCreate(), l = this._permissionService.composePermission$([new Ze(r).id, new Pe(r, s).id]).pipe(ft((u) => u.every((g) => g.value)));
-          l == null || l.pipe(
-            Me((u) => u !== o),
-            De()
+          const transformer = scene.getTransformerByCreate(), composeWorksheetEditPermission = this._permissionService.composePermission$([new WorkbookEditablePermission(unitId).id, new WorksheetEditPermission(unitId, subUnitId).id]).pipe(map((permissions) => permissions.every((item) => item.value)));
+          composeWorksheetEditPermission == null || composeWorksheetEditPermission.pipe(
+            filter((permission) => permission !== initialEditPermission),
+            distinctUntilChanged()
           ).subscribe({
-            next: (u) => {
-              o = u, this._drawingManagerService.setDrawingEditable(u);
-              const g = d.getAllObjects(), f = this._drawingManagerService.getDrawingData(r, s), m = Object.values(f);
-              u ? (g.forEach((p) => {
-                p.classType === ae.IMAGE && m.some((S) => p.oKey.includes(S.drawingId)) && d.attachTransformerTo(p);
-              }), this._drawingManagerService.addNotification(m)) : (g.forEach((p) => {
-                p.classType === ae.IMAGE && m.some((S) => p.oKey.includes(S.drawingId)) && d.detachTransformerFrom(p);
-              }), h.clearSelectedObjects());
-            }
-          }), (c = this._permissionService.getPermissionPoint$(new Pe(r, s).id)) == null || c.pipe(
-            Me((u) => u.value !== o),
-            De()
+            next: /* @__PURE__ */ __name((permission) => {
+              initialEditPermission = permission, this._drawingManagerService.setDrawingEditable(permission);
+              const objects = scene.getAllObjects(), drawingData = this._drawingManagerService.getDrawingData(unitId, subUnitId), drawingDataValues = Object.values(drawingData);
+              permission ? (objects.forEach((object) => {
+                object.classType === RENDER_CLASS_TYPE.IMAGE && drawingDataValues.some((item) => object.oKey.includes(item.drawingId)) && scene.attachTransformerTo(object);
+              }), this._drawingManagerService.addNotification(drawingDataValues)) : (objects.forEach((object) => {
+                object.classType === RENDER_CLASS_TYPE.IMAGE && drawingDataValues.some((item) => object.oKey.includes(item.drawingId)) && scene.detachTransformerFrom(object);
+              }), transformer.clearSelectedObjects());
+            }, "next")
+          }), (_a10 = this._permissionService.getPermissionPoint$(new WorksheetEditPermission(unitId, subUnitId).id)) == null || _a10.pipe(
+            filter((permission) => permission.value !== initialEditPermission),
+            distinctUntilChanged()
           ).subscribe({
-            complete: () => {
-              o = !0;
-              const u = e.getUnitId(), g = t.getSheetId(), f = this._drawingManagerService.getDrawingData(u, g), m = Object.values(f), p = this._renderManagerService.getRenderById(u), S = p == null ? void 0 : p.scene;
-              if (S == null)
+            complete: /* @__PURE__ */ __name(() => {
+              initialEditPermission = !0;
+              const unitId2 = workbook.getUnitId(), subUnitId2 = sheet.getSheetId(), drawingData = this._drawingManagerService.getDrawingData(unitId2, subUnitId2), drawingDataValues = Object.values(drawingData), renderObject2 = this._renderManagerService.getRenderById(unitId2), scene2 = renderObject2 == null ? void 0 : renderObject2.scene;
+              if (scene2 == null)
                 return;
-              this._drawingManagerService.setDrawingEditable(!0), S.getAllObjects().forEach((v) => {
-                v.classType === ae.IMAGE && m.some((R) => v.oKey.includes(R.drawingId)) && S.detachTransformerFrom(v);
+              this._drawingManagerService.setDrawingEditable(!0), scene2.getAllObjects().forEach((object) => {
+                object.classType === RENDER_CLASS_TYPE.IMAGE && drawingDataValues.some((item) => object.oKey.includes(item.drawingId)) && scene2.detachTransformerFrom(object);
               });
-            }
+            }, "complete")
           });
         });
       })
     );
   }
-};
-je = vi([
-  ie(se.Rendered, je),
-  fe(0, z),
-  fe(1, K),
-  fe(2, ln),
-  fe(3, he),
-  fe(4, W(dn))
-], je);
-var Si = Object.defineProperty, Ci = Object.getOwnPropertyDescriptor, Ii = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? Ci(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && Si(e, n, r), r;
-}, Ke = (i, e) => (n, t) => e(n, t, i);
-let Le = class extends oe {
-  constructor(e, n, t) {
+}, __name(_a7, "SheetDrawingPermissionController"), _a7);
+SheetDrawingPermissionController = __decorateClass$2([
+  OnLifecycle(LifecycleStages.Rendered, SheetDrawingPermissionController),
+  __decorateParam$2(0, IDrawingManagerService),
+  __decorateParam$2(1, IRenderManagerService),
+  __decorateParam$2(2, IPermissionService),
+  __decorateParam$2(3, IUniverInstanceService),
+  __decorateParam$2(4, Inject(UserManagerService))
+], SheetDrawingPermissionController);
+var __defProp$1 = Object.defineProperty, __getOwnPropDesc$1 = Object.getOwnPropertyDescriptor, __decorateClass$1 = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc$1(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp$1(target, key, result), result;
+}, "__decorateClass$1"), __decorateParam$1 = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam$1"), _a8;
+let SheetsDrawingCopyPasteController = (_a8 = class extends Disposable {
+  constructor(_sheetClipboardService, _renderManagerService, _sheetDrawingService) {
     super();
-    H(this, "_copyInfo");
-    this._sheetClipboardService = e, this._renderManagerService = n, this._sheetDrawingService = t, this._initCopyPaste();
+    __publicField(this, "_copyInfo");
+    this._sheetClipboardService = _sheetClipboardService, this._renderManagerService = _renderManagerService, this._sheetDrawingService = _sheetDrawingService, this._initCopyPaste();
   }
   _initCopyPaste() {
     this._sheetClipboardService.addClipboardHook({
       id: "SHEET_IMAGE_UI_PLUGIN",
-      onBeforeCopy: (e, n, t) => this._collect(e, n, t),
-      onPasteCells: (e, n, t, r) => {
-        const { copyType: s = gt.COPY, pasteType: o } = r, { range: a } = e || {}, { range: d, unitId: h, subUnitId: l } = n;
-        return this._generateMutations(d, { copyType: s, pasteType: o, copyRange: a, unitId: h, subUnitId: l });
-      },
-      onPastePlainText: (e, n) => ({ undos: [], redos: [] })
+      onBeforeCopy: /* @__PURE__ */ __name((unitId, subUnitId, range) => this._collect(unitId, subUnitId, range), "onBeforeCopy"),
+      onPasteCells: /* @__PURE__ */ __name((pasteFrom, pasteTo, data, payload) => {
+        const { copyType = COPY_TYPE.COPY, pasteType } = payload, { range: copyRange } = pasteFrom || {}, { range: pastedRange, unitId, subUnitId } = pasteTo;
+        return this._generateMutations(pastedRange, { copyType, pasteType, copyRange, unitId, subUnitId });
+      }, "onPasteCells"),
+      onPastePlainText: /* @__PURE__ */ __name((pasteTo, clipText) => ({ undos: [], redos: [] }), "onPastePlainText")
     });
   }
-  _collect(e, n, t) {
-    var u;
-    const r = (u = this._renderManagerService.getRenderById(e)) == null ? void 0 : u.with(re);
-    if (!r) return;
-    const s = r.attachRangeWithCoord(t);
-    if (!s)
+  _collect(unitId, subUnitId, range) {
+    var _a10;
+    const skeletonManagetService = (_a10 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a10.with(SheetSkeletonManagerService);
+    if (!skeletonManagetService) return;
+    const selectionRect = skeletonManagetService.attachRangeWithCoord(range);
+    if (!selectionRect)
       return;
-    const { startX: o, endX: a, startY: d, endY: h } = s, l = this._sheetDrawingService.getDrawingData(e, n), c = [];
-    Object.keys(l).forEach((g) => {
-      const f = l[g], { transform: m } = f;
-      if (f.anchorType !== O.Both || !m)
+    const { startX, endX, startY, endY } = selectionRect, drawings = this._sheetDrawingService.getDrawingData(unitId, subUnitId), containedDrawings = [];
+    Object.keys(drawings).forEach((drawingId) => {
+      const drawing = drawings[drawingId], { transform } = drawing;
+      if (drawing.anchorType !== SheetDrawingAnchorType.Both || !transform)
         return;
-      const { left: p = 0, top: S = 0, width: C = 0, height: v = 0 } = m, { drawingStartX: R, drawingEndX: _, drawingStartY: b, drawingEndY: w } = {
-        drawingStartX: p,
-        drawingEndX: p + C,
-        drawingStartY: S,
-        drawingEndY: S + v
+      const { left = 0, top = 0, width = 0, height = 0 } = transform, { drawingStartX, drawingEndX, drawingStartY, drawingEndY } = {
+        drawingStartX: left,
+        drawingEndX: left + width,
+        drawingStartY: top,
+        drawingEndY: top + height
       };
-      o <= R && _ <= a && d <= b && w <= h && c.push(f);
-    }), c.length && (this._copyInfo = {
-      drawings: c,
-      unitId: e,
-      subUnitId: n
+      startX <= drawingStartX && drawingEndX <= endX && startY <= drawingStartY && drawingEndY <= endY && containedDrawings.push(drawing);
+    }), containedDrawings.length && (this._copyInfo = {
+      drawings: containedDrawings,
+      unitId,
+      subUnitId
     });
   }
   // eslint-disable-next-line max-lines-per-function
-  _generateMutations(e, n) {
-    var D;
+  _generateMutations(pastedRange, copyInfo) {
+    var _a10;
     if (!this._copyInfo)
       return { redos: [], undos: [] };
     if ([
-      Ie.SPECIAL_PASTE_COL_WIDTH,
-      Ie.SPECIAL_PASTE_VALUE,
-      Ie.SPECIAL_PASTE_FORMAT,
-      Ie.SPECIAL_PASTE_FORMULA
+      PREDEFINED_HOOK_NAME.SPECIAL_PASTE_COL_WIDTH,
+      PREDEFINED_HOOK_NAME.SPECIAL_PASTE_VALUE,
+      PREDEFINED_HOOK_NAME.SPECIAL_PASTE_FORMAT,
+      PREDEFINED_HOOK_NAME.SPECIAL_PASTE_FORMULA
     ].includes(
-      n.pasteType
+      copyInfo.pasteType
     ))
       return { redos: [], undos: [] };
-    const { copyRange: t } = n;
-    if (!t)
+    const { copyRange } = copyInfo;
+    if (!copyRange)
       return { redos: [], undos: [] };
-    const { drawings: r, unitId: s, subUnitId: o } = this._copyInfo, { ranges: [a, d], mapFunc: h } = Bn([t, e]), { row: l, col: c } = h(a.startRow, a.startColumn), { row: u, col: g } = h(d.startRow, d.startColumn), f = (D = this._renderManagerService.getRenderById(s)) == null ? void 0 : D.with(re);
-    if (!f)
+    const { drawings, unitId, subUnitId } = this._copyInfo, { ranges: [vCopyRange, vPastedRange], mapFunc } = virtualizeDiscreteRanges([copyRange, pastedRange]), { row: copyRow, col: copyCol } = mapFunc(vCopyRange.startRow, vCopyRange.startColumn), { row: pasteRow, col: pasteCol } = mapFunc(vPastedRange.startRow, vPastedRange.startColumn), skeletonManagetService = (_a10 = this._renderManagerService.getRenderById(unitId)) == null ? void 0 : _a10.with(SheetSkeletonManagerService);
+    if (!skeletonManagetService)
       return { redos: [], undos: [] };
-    const m = f.attachRangeWithCoord({
-      startRow: l,
-      endRow: l,
-      startColumn: c,
-      endColumn: c
-    }), p = f.attachRangeWithCoord({
-      startRow: u,
-      endRow: u,
-      startColumn: g,
-      endColumn: g
+    const copyRect = skeletonManagetService.attachRangeWithCoord({
+      startRow: copyRow,
+      endRow: copyRow,
+      startColumn: copyCol,
+      endColumn: copyCol
+    }), pasteRect = skeletonManagetService.attachRangeWithCoord({
+      startRow: pasteRow,
+      endRow: pasteRow,
+      startColumn: pasteCol,
+      endColumn: pasteCol
     });
-    if (!m || !p)
+    if (!copyRect || !pasteRect)
       return { redos: [], undos: [] };
-    const S = [], C = [], v = p.startX - m.startX, R = p.startY - m.startY, _ = u - l, b = g - c, w = n.copyType === gt.CUT, { _sheetDrawingService: P } = this;
-    return r.forEach((T) => {
-      const { transform: U, sheetTransform: M } = T;
-      if (!U)
+    const redos = [], undos = [], leftOffset = pasteRect.startX - copyRect.startX, topOffset = pasteRect.startY - copyRect.startY, rowOffset = pasteRow - copyRow, columnOffset = pasteCol - copyCol, isCut = copyInfo.copyType === COPY_TYPE.CUT, { _sheetDrawingService } = this;
+    return drawings.forEach((drawing) => {
+      const { transform, sheetTransform } = drawing;
+      if (!transform)
         return;
-      const I = {
-        ...T,
-        unitId: s,
-        subUnitId: o,
-        drawingId: w ? T.drawingId : ne.generateRandomId(),
+      const drawingObject = {
+        ...drawing,
+        unitId,
+        subUnitId,
+        drawingId: isCut ? drawing.drawingId : Tools.generateRandomId(),
         transform: {
-          ...U,
-          left: U.left + v,
-          top: U.top + R
+          ...transform,
+          left: transform.left + leftOffset,
+          top: transform.top + topOffset
         },
         sheetTransform: {
-          to: { ...M.to, row: M.to.row + _, column: M.to.column + b },
-          from: { ...M.from, row: M.from.row + _, column: M.from.column + b }
+          to: { ...sheetTransform.to, row: sheetTransform.to.row + rowOffset, column: sheetTransform.to.column + columnOffset },
+          from: { ...sheetTransform.from, row: sheetTransform.from.row + rowOffset, column: sheetTransform.from.column + columnOffset }
         }
       };
-      if (w) {
-        const { undo: A, redo: G, objects: J } = P.getBatchUpdateOp([I]);
-        S.push({
-          id: E.id,
+      if (isCut) {
+        const { undo, redo, objects } = _sheetDrawingService.getBatchUpdateOp([drawingObject]);
+        redos.push({
+          id: SetDrawingApplyMutation.id,
           params: {
-            unitId: s,
-            subUnitId: o,
-            type: y.UPDATE,
-            op: G,
-            objects: J
+            unitId,
+            subUnitId,
+            type: DrawingApplyType.UPDATE,
+            op: redo,
+            objects
           }
-        }), C.push({
-          id: E.id,
+        }), undos.push({
+          id: SetDrawingApplyMutation.id,
           params: {
-            unitId: s,
-            subUnitId: o,
-            type: y.UPDATE,
-            op: A,
-            objects: J
+            unitId,
+            subUnitId,
+            type: DrawingApplyType.UPDATE,
+            op: undo,
+            objects
           }
         });
       } else {
-        const { undo: A, redo: G, objects: J } = P.getBatchAddOp([I]);
-        S.push({ id: E.id, params: { op: G, unitId: s, subUnitId: o, objects: J, type: y.INSERT } }), C.push({ id: E.id, params: { op: A, unitId: s, subUnitId: o, objects: J, type: y.REMOVE } });
+        const { undo, redo, objects } = _sheetDrawingService.getBatchAddOp([drawingObject]);
+        redos.push({ id: SetDrawingApplyMutation.id, params: { op: redo, unitId, subUnitId, objects, type: DrawingApplyType.INSERT } }), undos.push({ id: SetDrawingApplyMutation.id, params: { op: undo, unitId, subUnitId, objects, type: DrawingApplyType.REMOVE } });
       }
     }), {
-      redos: S,
-      undos: C
+      redos,
+      undos
     };
   }
-};
-Le = Ii([
-  ie(se.Ready, Le),
-  Ke(0, Wn),
-  Ke(1, K),
-  Ke(2, k)
-], Le);
-var qt = Object.defineProperty, Ri = Object.getOwnPropertyDescriptor, Mi = (i, e, n) => e in i ? qt(i, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : i[e] = n, Di = (i, e, n, t) => {
-  for (var r = t > 1 ? void 0 : t ? Ri(e, n) : e, s = i.length - 1, o; s >= 0; s--)
-    (o = i[s]) && (r = (t ? o(e, n, r) : o(r)) || r);
-  return t && r && qt(e, n, r), r;
-}, Je = (i, e) => (n, t) => e(n, t, i), Qt = (i, e, n) => Mi(i, typeof e != "symbol" ? e + "" : e, n);
-const bi = "SHEET_IMAGE_UI_PLUGIN";
-let $e = class extends un {
-  constructor(e = {}, n, t, r) {
+}, __name(_a8, "SheetsDrawingCopyPasteController"), _a8);
+SheetsDrawingCopyPasteController = __decorateClass$1([
+  OnLifecycle(LifecycleStages.Ready, SheetsDrawingCopyPasteController),
+  __decorateParam$1(0, ISheetClipboardService),
+  __decorateParam$1(1, IRenderManagerService),
+  __decorateParam$1(2, ISheetDrawingService)
+], SheetsDrawingCopyPasteController);
+var __defProp2 = Object.defineProperty, __getOwnPropDesc = Object.getOwnPropertyDescriptor, __defNormalProp2 = /* @__PURE__ */ __name((obj, key, value) => key in obj ? __defProp2(obj, key, { enumerable: !0, configurable: !0, writable: !0, value }) : obj[key] = value, "__defNormalProp"), __decorateClass = /* @__PURE__ */ __name((decorators, target, key, kind) => {
+  for (var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target, i = decorators.length - 1, decorator; i >= 0; i--)
+    (decorator = decorators[i]) && (result = (kind ? decorator(target, key, result) : decorator(result)) || result);
+  return kind && result && __defProp2(target, key, result), result;
+}, "__decorateClass"), __decorateParam = /* @__PURE__ */ __name((index, decorator) => (target, key) => decorator(target, key, index), "__decorateParam"), __publicField2 = /* @__PURE__ */ __name((obj, key, value) => __defNormalProp2(obj, typeof key != "symbol" ? key + "" : key, value), "__publicField");
+const PLUGIN_NAME = "SHEET_IMAGE_UI_PLUGIN";
+var _a9;
+let UniverSheetsDrawingUIPlugin = (_a9 = class extends Plugin {
+  constructor(config = {}, _injector, _localeService, _renderManagerService) {
     super();
-    H(this, "_pluginConfig");
-    this._injector = n, this._localeService = t, this._renderManagerService = r, this._pluginConfig = ne.deepMerge({}, ii, e);
+    __publicField(this, "_pluginConfig");
+    this._injector = _injector, this._localeService = _localeService, this._renderManagerService = _renderManagerService, this._pluginConfig = Tools.deepMerge({}, DefaultSheetsDrawingConfig, config);
   }
-  onStarting(e) {
-    super.onStarting(e), this._initDependencies(e);
+  onStarting() {
+    this._initDependencies();
   }
   onRendered() {
     this._registerRenderModules();
   }
-  _initDependencies(e) {
-    const n = [
-      // services
-      [tt],
-      // controllers
-      [
-        pe,
-        {
-          useFactory: () => this._injector.createInstance(pe, this._pluginConfig)
-        }
-      ],
-      [Te],
-      [Ne],
-      [je]
-    ], t = [
-      Ue,
-      Ae
-    ];
-    n.forEach((r) => e.add(r)), t.forEach((r) => this._renderManagerService.registerRenderModule(B.UNIVER_SHEET, r));
+  _initDependencies() {
+    [
+      [SheetCanvasFloatDomManagerService],
+      [SheetDrawingUIController, {
+        useFactory: /* @__PURE__ */ __name(() => this._injector.createInstance(SheetDrawingUIController, this._pluginConfig), "useFactory")
+      }],
+      [DrawingPopupMenuController],
+      [SheetDrawingPrintingController],
+      [SheetDrawingPermissionController]
+    ].forEach((dependency) => this._injector.add(dependency));
   }
   _registerRenderModules() {
     [
-      [Le]
-    ].forEach((e) => {
-      this.disposeWithMe(this._renderManagerService.registerRenderModule(B.UNIVER_SHEET, e));
+      [SheetDrawingUpdateController],
+      [SheetDrawingTransformAffectedController],
+      [SheetsDrawingCopyPasteController]
+    ].forEach((m) => {
+      this.disposeWithMe(this._renderManagerService.registerRenderModule(UniverInstanceType.UNIVER_SHEET, m));
     });
   }
-};
-Qt($e, "type", B.UNIVER_SHEET);
-Qt($e, "pluginName", bi);
-$e = Di([
-  gn(Dn, vn, Sn),
-  Je(1, W(nt)),
-  Je(2, W(_e)),
-  Je(3, K)
-], $e);
+}, __name(_a9, "UniverSheetsDrawingUIPlugin"), _a9);
+__publicField2(UniverSheetsDrawingUIPlugin, "type", UniverInstanceType.UNIVER_SHEET);
+__publicField2(UniverSheetsDrawingUIPlugin, "pluginName", PLUGIN_NAME);
+UniverSheetsDrawingUIPlugin = __decorateClass([
+  DependentOn(UniverDrawingPlugin, UniverDrawingUIPlugin, UniverSheetsDrawingPlugin),
+  __decorateParam(1, Inject(Injector)),
+  __decorateParam(2, Inject(LocaleService)),
+  __decorateParam(3, IRenderManagerService)
+], UniverSheetsDrawingUIPlugin);
 export {
-  j as ClearSheetDrawingTransformerOperation,
-  Zt as DeleteDrawingsCommand,
-  Gt as EditSheetDrawingOperation,
-  Ft as GroupSheetDrawingCommand,
-  Be as InsertCellImageOperation,
-  xe as InsertFloatImageOperation,
-  st as InsertSheetDrawingCommand,
-  ve as MoveDrawingsCommand,
-  it as RemoveSheetDrawingCommand,
-  xt as SetDrawingArrangeCommand,
-  Fe as SetSheetDrawingCommand,
-  tt as SheetCanvasFloatDomManagerService,
-  Vt as SidebarSheetDrawingOperation,
-  Yt as UngroupSheetDrawingCommand,
-  $e as UniverSheetsDrawingUIPlugin
+  ClearSheetDrawingTransformerOperation,
+  DeleteDrawingsCommand,
+  EditSheetDrawingOperation,
+  GroupSheetDrawingCommand,
+  InsertCellImageOperation,
+  InsertFloatImageOperation,
+  InsertSheetDrawingCommand,
+  MoveDrawingsCommand,
+  RemoveSheetDrawingCommand,
+  SetDrawingArrangeCommand,
+  SetSheetDrawingCommand,
+  SheetCanvasFloatDomManagerService,
+  SidebarSheetDrawingOperation,
+  UngroupSheetDrawingCommand,
+  UniverSheetsDrawingUIPlugin
 };