@netless/appliance-plugin 1.1.42 → 1.1.43-beta.0

package/dist/index-BNHPCii1.mjs

@@ -0,0 +1,4089 @@
+var ye = Object.defineProperty;
+var we = (M, e, t) => e in M ? ye(M, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : M[e] = t;
+var u = (M, e, t) => we(M, typeof e != "symbol" ? e + "" : e, t);
+import { D as K, e as b, c as m, r as $, b as R, g as Z, t as V, a as h, f as de, M as ve, h as D, i as j, j as ke, C as H, k as z, l as Se, m as te, n as Ie, o as se, p as ge, q as Te, s as re, u as ie, v as Y, w as _, E as N, x as ee, y as Q, z as We, A as Re, B as Ee, F as be, G as Le, H as pe, I as ue, T as oe, J as ae, K as Ce, L as Ne, N as fe, P as me, Q as ne, R as Oe, S as ce, U as q, W as Be, V as he, X as De } from "./index-NG5kKK1W.mjs";
+import { cloneDeep as J, xor as Me, isNumber as G, isEqual as le } from "lodash";
+import "clipper-lib";
+import "lineclip";
+import "rbush";
+import "xss";
+import "white-web-sdk";
+import "react-dom";
+import "react";
+class Pe {
+  constructor(e) {
+    u(this, "vNodes");
+    u(this, "thread");
+    u(this, "serviceWorkShapes", /* @__PURE__ */ new Map());
+    u(this, "localWorkShapes", /* @__PURE__ */ new Map());
+    u(this, "tmpOpt");
+    u(this, "animationId");
+    u(this, "syncUnitTime", K.syncOpt.interval);
+    this.vNodes = e.vNodes, this.thread = e.thread;
+  }
+  createLocalWork(e) {
+    const { workId: t, opt: s, toolsType: r } = e;
+    if (t && s) {
+      const i = t.toString();
+      !this.getToolsOpt() && r && this.setToolsOpt({
+        toolsType: r,
+        toolsOpt: s
+      }), this.setWorkOptions(i, s);
+    }
+  }
+  getLocalWorkShape(e) {
+    return this.localWorkShapes.get(e);
+  }
+  createLocalWorkShape(e, t) {
+    if (e && this.tmpOpt) {
+      const s = {
+        toolsType: this.tmpOpt.toolsType,
+        toolsOpt: t || this.tmpOpt.toolsOpt
+      }, r = this.createWorkShapeNode({ ...s, workId: e });
+      return r && this.localWorkShapes.set(e, {
+        node: r,
+        toolsType: r.toolsType,
+        workState: b.Start
+      }), r;
+    }
+  }
+  canUseTopLayer(e) {
+    return e === m.LaserPen;
+  }
+  destroy() {
+    this.clearAll();
+  }
+  clearAll() {
+    this.thread.topLayer.children.length && (this.thread.topLayer.parent.children.forEach((e) => {
+      e.name !== "viewport" && e.remove();
+    }), $(
+      this.thread.serviceLayer,
+      this.thread.serviceLayer.parent
+    )), this.serviceWorkShapes.clear(), this.localWorkShapes.clear();
+  }
+  consumeDraw(e) {
+    const { workId: t, dataType: s } = e;
+    if (s === R.Service)
+      this.activeServiceWorkShape(e);
+    else {
+      const r = t == null ? void 0 : t.toString(), i = r && this.localWorkShapes.get(r);
+      if (!i)
+        return;
+      const o = i.node.consume({
+        data: e,
+        isFullWork: !1,
+        isSubWorker: !0
+      });
+      o.rect && (i.result = o, i.workState = b.Doing, r && this.localWorkShapes.set(r, i));
+    }
+    this.runAnimation();
+  }
+  setToolsOpt(e) {
+    var t;
+    this.tmpOpt = e, (t = e.toolsOpt) != null && t.syncUnitTime && (this.syncUnitTime = e.toolsOpt.syncUnitTime);
+  }
+  getToolsOpt() {
+    return this.tmpOpt;
+  }
+  createWorkShapeNode(e) {
+    const { toolsType: t } = e;
+    if (t === m.LaserPen)
+      return Z({
+        ...e,
+        vNodes: this.vNodes,
+        fullLayer: this.thread.topLayer,
+        drawLayer: this.thread.topLayer
+      });
+  }
+  setNodeKey(e, t, s, r) {
+    return t.toolsType = s, t.node = this.createWorkShapeNode({
+      workId: e,
+      toolsType: s,
+      toolsOpt: r
+    }), t;
+  }
+  activeServiceWorkShape(e) {
+    var p, f;
+    const { workId: t, opt: s, toolsType: r, type: i, updateNodeOpt: o, ops: a, op: n } = e;
+    if (!t)
+      return;
+    const c = t.toString(), d = (p = this.vNodes.get(c)) == null ? void 0 : p.rect;
+    if (!((f = this.serviceWorkShapes) != null && f.has(c))) {
+      let w = {
+        toolsType: r,
+        animationWorkData: n || [],
+        animationIndex: 0,
+        type: i,
+        updateNodeOpt: o,
+        ops: a,
+        oldRect: d
+      };
+      r && s && (w = this.setNodeKey(c, w, r, s)), this.serviceWorkShapes.set(c, w);
+    }
+    const l = this.serviceWorkShapes.get(c);
+    i && (l.type = i), a && (l.animationWorkData = V(a), l.ops = a), o && (l.updateNodeOpt = o), n && (l.animationWorkData = n), l.node && l.node.getWorkId() !== c && l.node.setWorkId(c), d && (l.oldRect = d), r && s && (l.toolsType !== r && r && s && this.setNodeKey(c, l, r, s), l.node && l.node.setWorkOptions(s));
+  }
+  computNextAnimationIndex(e, t) {
+    var i;
+    const s = ((i = e.node) == null ? void 0 : i.syncUnitTime) || this.syncUnitTime, r = Math.floor(
+      (e.animationWorkData || []).slice(e.animationIndex).length * 32 / t / s
+    ) * t;
+    return Math.min(
+      (e.animationIndex || 0) + (r || t),
+      (e.animationWorkData || []).length
+    );
+  }
+  animationDraw() {
+    var r, i, o, a;
+    this.animationId = void 0;
+    let e = !1;
+    const t = /* @__PURE__ */ new Map(), s = [];
+    for (const [n, c] of this.serviceWorkShapes.entries())
+      switch (c.toolsType) {
+        case m.LaserPen: {
+          const l = this.computNextAnimationIndex(
+            c,
+            8
+          ), p = Math.max(0, c.animationIndex || 0), f = (c.animationWorkData || []).slice(
+            p,
+            l
+          );
+          if ((c.animationIndex || 0) < l && ((r = c.node) == null || r.consumeService({
+            op: f,
+            isFullWork: !1
+          }), c.animationIndex = l, f.length && t.set(n, {
+            workState: p === 0 ? b.Start : l === ((i = c.animationWorkData) == null ? void 0 : i.length) ? b.Done : b.Doing,
+            op: f.slice(-2)
+          })), c.isDel) {
+            (o = c.node) == null || o.clearTmpPoints(), this.serviceWorkShapes.delete(n);
+            break;
+          }
+          c.ops && c.animationIndex === ((a = c.animationWorkData) == null ? void 0 : a.length) && !c.isDel && (this.thread.topLayer.getElementsByName(
+            n.toString()
+          )[0] || (c.isDel = !0, this.serviceWorkShapes.set(n, c))), e = !0;
+          break;
+        }
+      }
+    for (const [n, c] of this.localWorkShapes.entries()) {
+      const { result: d, toolsType: l, isDel: p, workState: f } = c;
+      switch (l) {
+        case m.LaserPen: {
+          if (p) {
+            c.node.clearTmpPoints(), this.localWorkShapes.delete(n), s.push({
+              removeIds: [n.toString()],
+              type: h.RemoveNode
+            });
+            break;
+          }
+          d && ((d.op || d.ops) && s.push(d), c.result = void 0), !this.thread.topLayer.getElementsByName(
+            n.toString()
+          )[0] && f === b.Done && (c.isDel = !0, this.localWorkShapes.set(n, c)), e = !0;
+          break;
+        }
+      }
+    }
+    e && this.runAnimation(), t.size && t.forEach((n, c) => {
+      s.push({
+        type: h.Cursor,
+        uid: c.split(de)[0],
+        op: n.op,
+        workState: n.workState,
+        viewId: this.thread.viewId
+      });
+    }), s.length && this.thread.post({ sp: s });
+  }
+  runAnimation() {
+    this.animationId || (this.animationId = requestAnimationFrame(this.animationDraw.bind(this)));
+  }
+  setWorkOptions(e, t) {
+    var r;
+    let s = (r = this.localWorkShapes.get(e)) == null ? void 0 : r.node;
+    if (!s && this.tmpOpt) {
+      const { toolsType: i } = this.tmpOpt;
+      this.tmpOpt.toolsOpt = t, s = this.createWorkShapeNode({ workId: e, toolsType: i, toolsOpt: t }), s && this.localWorkShapes.set(e, {
+        node: s,
+        toolsType: i,
+        workState: b.Start
+      }), this.setToolsOpt(this.tmpOpt);
+    }
+    t != null && t.syncUnitTime || (t.syncUnitTime = this.syncUnitTime), s && s.setWorkOptions(t);
+  }
+  consumeDrawAll(e) {
+    const { workId: t, dataType: s } = e;
+    if (s === R.Service)
+      this.activeServiceWorkShape(e);
+    else {
+      const r = t == null ? void 0 : t.toString(), i = r && this.localWorkShapes.get(r);
+      if (!i)
+        return;
+      const o = i.node.consumeAll({
+        data: e
+      });
+      i.result = o, i.workState = b.Done, r && this.localWorkShapes.set(r, i);
+    }
+    this.runAnimation();
+  }
+}
+class Ae {
+  constructor(e) {
+    u(this, "vNodes");
+    u(this, "thread");
+    u(this, "workShapes", /* @__PURE__ */ new Map());
+    u(this, "effectSelectNodeData", /* @__PURE__ */ new Set());
+    u(this, "batchEraserRemoveNodes", /* @__PURE__ */ new Set());
+    u(this, "batchEraserWorks", /* @__PURE__ */ new Set());
+    u(this, "tmpOpt");
+    u(this, "syncUnitTime", K.syncOpt.interval);
+    u(this, "fullWorkerDrawCount", 0);
+    u(this, "drawWorkActiveId");
+    u(this, "consumeCount", 0);
+    u(this, "combineDrawActiveId");
+    u(this, "eraserBatchScheduler", new ve());
+    u(this, "disposeVNodeRevisionObserver");
+    u(this, "bitmapEraserRenderQueue", Promise.resolve());
+    u(this, "bitmapEraserRevalidationQueued", !1);
+    this.vNodes = e.vNodes, this.thread = e.thread, this.disposeVNodeRevisionObserver = this.vNodes.observeRevision(() => {
+      this.scheduleActiveBitmapEraserRevalidation();
+    });
+  }
+  scheduleActiveBitmapEraserRevalidation() {
+    const e = this.combineDrawActiveId;
+    if (!e) return;
+    const t = this.getWorkShape(e);
+    (t == null ? void 0 : t.toolsType) !== m.BitMapEraser || !t.shouldRevalidateVNodeRevision() || this.bitmapEraserRevalidationQueued || (this.bitmapEraserRevalidationQueued = !0, this.enqueueBitmapEraserRender(e).catch((s) => {
+      this.thread.master.Logger.error(
+        `[Appliance]: Bitmap Eraser revision revalidation failed; viewId=${this.thread.viewId}; workId=${e}; error=${s instanceof Error ? s.message : String(s)}`
+      );
+    }).finally(() => {
+      this.bitmapEraserRevalidationQueued = !1;
+    }));
+  }
+  async loadImageBitMap(e) {
+    return await this.thread.loadImageBitMap(e);
+  }
+  createLocalWork(e) {
+    const { workId: t, opt: s, toolsType: r } = e;
+    if (t && s) {
+      const i = t.toString();
+      !this.getToolsOpt() && r && this.setToolsOpt({
+        toolsType: r,
+        toolsOpt: s
+      }), this.setWorkOptions(i, s);
+    }
+  }
+  // async workShapesDone(scenePath: string, serviceWork: SubServiceThread) {
+  //     for (const key of this.workShapes.keys()) {
+  //         await this.consumeDrawAll({
+  //             workId: key,
+  //             scenePath,
+  //             viewId: this.thread.viewId,
+  //             msgType: EPostMessageType.DrawWork,
+  //             dataType: EDataType.Local
+  //         }, serviceWork)
+  //     }
+  // }
+  async updateSelector(e) {
+    var f;
+    const t = this.workShapes.get(
+      D
+    );
+    if (!((f = t == null ? void 0 : t.selectIds) != null && f.length)) return;
+    const { callback: s, ...r } = e, { updateSelectorOpt: i, willSerializeData: o, smoothSync: a } = r, n = await (t == null ? void 0 : t.updateSelector({
+      updateSelectorOpt: i,
+      selectIds: J(t.selectIds),
+      vNodes: this.vNodes,
+      willSerializeData: o,
+      worker: this
+    })), c = /* @__PURE__ */ new Map();
+    let d;
+    n != null && n.selectIds && (d = Me(t.selectIds, n.selectIds), n.selectIds.forEach((w) => {
+      const k = this.vNodes.get(w);
+      if (k) {
+        const { toolsType: I, op: W, opt: g } = k;
+        c.set(w, {
+          opt: g,
+          toolsType: I,
+          ops: (W == null ? void 0 : W.length) && j(W) || void 0
+        });
+      }
+    }), t.selectIds = n.selectIds);
+    const l = [], p = s && s({
+      res: n,
+      workShapeNode: t,
+      param: r,
+      postData: { sp: l },
+      newServiceStore: c,
+      smoothSync: a
+    }) || { sp: l };
+    d && p.sp.push({
+      type: h.RemoveNode,
+      removeIds: d,
+      viewId: this.thread.viewId
+    }), p.sp.length && this.thread.post(p);
+  }
+  destroy() {
+    var e;
+    (e = this.disposeVNodeRevisionObserver) == null || e.call(this), this.disposeVNodeRevisionObserver = void 0, this.eraserBatchScheduler.cancel(), this.clearAll();
+  }
+  clearAll() {
+    if (this.eraserBatchScheduler.cancel(), this.thread.localLayer.children.length && (this.thread.topLayer.parent.children.forEach((t) => {
+      t.name !== "viewport" && t.remove();
+    }), $(
+      this.thread.localLayer,
+      this.thread.localLayer.parent
+    )), this.workShapes.get(
+      D
+    )) {
+      const t = [];
+      t.push({
+        type: h.Select,
+        dataType: R.Local,
+        selectIds: [],
+        willSyncService: !1
+      }), this.thread.post({ sp: t });
+    }
+    this.workShapes.forEach((t) => t.clearTmpPoints()), this.workShapes.clear(), this.effectSelectNodeData.clear(), this.batchEraserWorks.clear(), this.batchEraserRemoveNodes.clear();
+  }
+  async checkTextActive(e) {
+    const { op: t, viewId: s, dataType: r } = e;
+    if (t != null && t.length) {
+      let i;
+      for (const o of this.vNodes.curNodeMap.values()) {
+        const { rect: a, name: n, toolsType: c, opt: d } = o, l = t[0] * this.thread.fullLayer.worldScaling[0] + this.thread.fullLayer.worldPosition[0], p = t[1] * this.thread.fullLayer.worldScaling[1] + this.thread.fullLayer.worldPosition[1];
+        if (c === m.Text && ke([l, p], a) && d.workState === b.Done) {
+          i = n;
+          break;
+        }
+      }
+      i && (await this.blurSelector({
+        viewId: s,
+        msgType: h.Select,
+        dataType: r,
+        isSync: !0
+      }), this.thread.post({
+        sp: [
+          {
+            type: h.GetTextActive,
+            toolsType: m.Text,
+            workId: i
+          }
+        ]
+      }));
+    }
+  }
+  cursorHover(e) {
+    const { opt: t, toolsType: s, point: r } = e, i = this.setFullWork({
+      workId: H,
+      toolsType: s,
+      opt: t
+    });
+    i && r && i.cursorHover(r);
+  }
+  cursorBlur() {
+    var t;
+    const e = this.getWorkShape(H);
+    e && ((t = e.selectIds) != null && t.length) && (e.cursorBlur(), this.clearWorkShapeNodeCache(H)), this.thread.fullLayer.parent.children.forEach((s) => {
+      s.name === "Cursor_Hover_Id" && s.remove();
+    });
+  }
+  async updateFullSelectWork(e) {
+    var r, i, o, a, n;
+    const t = this.workShapes.get(
+      D
+    ), { selectIds: s } = e;
+    if (!(s != null && s.length)) {
+      await this.blurSelector(e);
+      return;
+    }
+    if (!t) {
+      this.setFullWork({
+        workId: D,
+        toolsType: m.Selector,
+        opt: e.opt || (((r = this.tmpOpt) == null ? void 0 : r.toolsType) === m.Selector ? this.tmpOpt.toolsOpt : {})
+      }) && await this.updateFullSelectWork(e);
+      return;
+    }
+    if (t && (s != null && s.length)) {
+      const { selectRect: c } = t.updateSelectIds(s), d = [
+        {
+          selectorColor: ((i = e.opt) == null ? void 0 : i.strokeColor) || t.selectorColor,
+          strokeColor: ((o = e.opt) == null ? void 0 : o.strokeColor) || t.strokeColor,
+          fillColor: ((a = e.opt) == null ? void 0 : a.fillColor) || t.fillColor,
+          textOpt: ((n = e.opt) == null ? void 0 : n.textOpt) || t.textOpt,
+          canTextEdit: t.canTextEdit,
+          canRotate: t.canRotate,
+          scaleType: t.scaleType,
+          type: h.Select,
+          viewId: this.thread.viewId,
+          dataType: R.Local,
+          selectIds: s,
+          selectRect: c,
+          points: t.getChildrenPoints(),
+          willSyncService: (e == null ? void 0 : e.willSyncService) || !1,
+          opt: (e == null ? void 0 : e.willSyncService) && t.getWorkOptions() || void 0,
+          canLock: t.canLock,
+          isLocked: t.isLocked,
+          toolsTypes: t.toolsTypes,
+          shapeOpt: t.shapeOpt,
+          thickness: t.thickness,
+          useStroke: t.useStroke,
+          strokeType: t.strokeType
+        }
+      ];
+      this.thread.post({ sp: d });
+    }
+  }
+  async removeSelector(e) {
+    const { willSyncService: t, needUndoTicker: s } = e, r = [], i = [], o = this.workShapes.get(
+      D
+    );
+    if (!o)
+      return;
+    const a = o.selectIds && [...o.selectIds] || [];
+    for (const n of a) {
+      const c = this.vNodes.get(n);
+      if (c)
+        switch (c.toolsType) {
+          case m.Text: {
+            r.push({
+              type: h.TextUpdate,
+              toolsType: m.Text,
+              workId: n,
+              dataType: R.Local
+            });
+            break;
+          }
+          case m.BackgroundSVG:
+            r.push({
+              type: h.BackgroundSVGDelete,
+              toolsType: m.BackgroundSVG,
+              workId: n,
+              dataType: R.Local,
+              viewId: this.thread.viewId
+            });
+            break;
+        }
+      this.removeNode(n), i.push(n);
+    }
+    i.length && r.push({
+      type: h.RemoveNode,
+      removeIds: i,
+      needUndoTicker: s,
+      emitEventType: e.emitEventType,
+      requestId: e.requestId
+    }), r.push({
+      type: h.Select,
+      selectIds: [],
+      willSyncService: t
+    }), await this.blurSelector(), s && r.push({
+      type: h.None,
+      needUndoTicker: s
+    }), r.length && this.thread.post({ sp: r });
+  }
+  removeWork(e) {
+    const { workId: t } = e, s = t == null ? void 0 : t.toString();
+    s && this.removeNode(s);
+  }
+  removeNode(e) {
+    var r;
+    const t = this.vNodes.get(e);
+    t && (t.toolsType === m.BackgroundSVG && this.thread.post({
+      sp: [
+        {
+          type: h.BackgroundSVGDelete,
+          toolsType: m.BackgroundSVG,
+          workId: e,
+          dataType: R.Local,
+          viewId: this.thread.viewId
+        }
+      ]
+    }), (r = this.thread.fullLayer) == null || r.getElementsByName(e).forEach((i) => {
+      i.remove(), z(i, this.thread.fullLayer.parent);
+    }), this.vNodes.delete(e)), this.workShapes.has(e) && (this.thread.localLayer.getElementsByName(e).forEach((i) => {
+      i.remove(), z(i, this.thread.localLayer.parent);
+    }), this.clearWorkShapeNodeCache(e));
+  }
+  setFullWork(e) {
+    const { workId: t, opt: s, toolsType: r } = e;
+    if (t && s && r) {
+      const i = t.toString();
+      let o;
+      return t && this.workShapes.has(i) ? (o = this.workShapes.get(i), (o == null ? void 0 : o.toolsType) !== r ? (o == null || o.clearTmpPoints(), this.workShapes.delete(i), o = void 0) : o == null || o.setWorkOptions(s)) : o = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: r,
+        workId: i
+      }), o || (o = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: r,
+        workId: i
+      })), o ? (this.workShapes.set(i, o), o) : void 0;
+    }
+  }
+  async consumeFull(e) {
+    var o, a;
+    const t = (o = e.workId) == null ? void 0 : o.toString(), s = (a = e.updateNodeOpt) == null ? void 0 : a.eraserGeometryDelta;
+    if (t) {
+      const n = this.vNodes.get(t), c = e.ops && V(e.ops) || e.op || [];
+      if (s) {
+        if (!n || !e.centerPos || !Se(
+          this.vNodes,
+          t,
+          s,
+          n,
+          { op: c, centerPos: e.centerPos }
+        )) {
+          te(this.vNodes, t);
+          return;
+        }
+      } else n && e.centerPos && Ie(this.vNodes, t) && se(n.op, n.centerPos) !== se(c, e.centerPos) && te(this.vNodes, t);
+    }
+    const r = this.setFullWork(e), i = e.ops && V(e.ops);
+    if (r) {
+      t && e.clearPreviewLocalWork && this.thread.localLayer.getElementsByName(t).forEach((c) => {
+        c.remove(), z(c, this.thread.localLayer.parent);
+      }), r.toolsType === m.BackgroundSVG ? r.consumeService({
+        isFullWork: !0,
+        replaceId: t
+      }) : r.toolsType === m.Image ? await r.consumeServiceAsync({
+        isFullWork: !0,
+        replaceId: t,
+        worker: this
+      }) : r.toolsType === m.Text ? await r.consumeServiceAsync({
+        isFullWork: !0,
+        replaceId: t,
+        boxRect: this.thread.getSceneRect()
+      }) : r.consumeService({
+        op: i,
+        isFullWork: !0,
+        replaceId: t
+      }), e != null && e.updateNodeOpt && r.updataOptService(e.updateNodeOpt);
+      const n = [];
+      e.workId && this.workShapes.delete(e.workId.toString()), e.willSyncService && n.push({
+        opt: e.opt,
+        toolsType: e.toolsType,
+        type: h.FullWork,
+        workId: e.workId,
+        ops: e.ops,
+        updateNodeOpt: e.updateNodeOpt,
+        viewId: this.thread.viewId,
+        needUndoTicker: e.needUndoTicker,
+        requestId: e.requestId,
+        emitEventType: e.emitEventType,
+        scenePath: e.scenePath
+      }), e.isLockSentEventCursor && n.push({
+        type: h.None,
+        isLockSentEventCursor: !0,
+        scenePath: e.scenePath
+      }), e.needUndoTicker && n.push({
+        type: h.None,
+        needUndoTicker: e.needUndoTicker,
+        emitEventType: e.emitEventType,
+        requestId: e.requestId,
+        scenePath: e.scenePath
+      }), n.length && this.thread.post({ sp: n });
+    }
+  }
+  async colloctEffectSelectWork(e) {
+    const t = this.workShapes.get(
+      D
+    ), { workId: s, msgType: r } = e;
+    if (t && s && t.selectIds && t.selectIds.includes(s.toString())) {
+      r === h.RemoveNode ? t.selectIds = t.selectIds.filter(
+        (i) => i !== s.toString()
+      ) : this.effectSelectNodeData.add(e), await this.runEffectSelectWork(!0);
+      return;
+    }
+    return e;
+  }
+  async runEffectSelectWork(e) {
+    var t;
+    for await (const s of this.effectSelectNodeData.values()) {
+      const r = this.setFullWork(s);
+      if (r) {
+        const i = (t = s.workId) == null ? void 0 : t.toString();
+        if (r.toolsType === m.BackgroundSVG)
+          r.consumeService({
+            isFullWork: !0,
+            replaceId: i
+          });
+        else if (r.toolsType === m.Image)
+          await r.consumeServiceAsync({
+            isFullWork: !0,
+            replaceId: i,
+            worker: this
+          });
+        else if (r.toolsType === m.Text)
+          await r.consumeServiceAsync({
+            isFullWork: !0,
+            replaceId: i,
+            boxRect: this.thread.getSceneRect()
+          });
+        else {
+          const o = s.ops && V(s.ops);
+          r.consumeService({
+            op: o,
+            isFullWork: !0,
+            replaceId: i
+          }), s != null && s.updateNodeOpt && r.updataOptService(s.updateNodeOpt);
+        }
+        s.workId && this.workShapes.delete(s.workId.toString());
+      }
+      this.effectSelectNodeData.delete(s);
+    }
+    this.reRenderSelector(e);
+  }
+  hasSelector() {
+    return this.workShapes.has(D);
+  }
+  getSelector() {
+    return this.workShapes.get(D);
+  }
+  reRenderSelector(e = !1) {
+    var r;
+    const t = this.workShapes.get(
+      D
+    );
+    if (!t) return;
+    if (t && !((r = t.selectIds) != null && r.length))
+      return this.blurSelector();
+    const s = t.reRenderSelector();
+    s && this.thread.post({
+      sp: [
+        {
+          type: h.Select,
+          selectIds: t.selectIds,
+          selectRect: s,
+          willSyncService: e,
+          viewId: this.thread.viewId,
+          points: t.getChildrenPoints(),
+          textOpt: t.textOpt,
+          selectorColor: t.selectorColor,
+          strokeColor: t.strokeColor,
+          fillColor: t.fillColor,
+          canTextEdit: t.canTextEdit,
+          canRotate: t.canRotate,
+          scaleType: t.scaleType,
+          opt: t.getWorkOptions() || void 0,
+          canLock: t.canLock,
+          isLocked: t.isLocked,
+          toolsTypes: t.toolsTypes,
+          shapeOpt: t.shapeOpt,
+          thickness: t.thickness,
+          useStroke: t.useStroke,
+          strokeType: t.strokeType
+        }
+      ]
+    });
+  }
+  async blurSelector(e) {
+    var r;
+    const t = this.workShapes.get(
+      D
+    ), s = t == null ? void 0 : t.blurSelector();
+    if (this.clearWorkShapeNodeCache(D), ((r = this.thread.fullLayer) == null ? void 0 : r.parent).children.forEach((i) => {
+      i.name === D && i.remove();
+    }), s) {
+      const i = [];
+      i.push({
+        ...s,
+        isSync: e == null ? void 0 : e.isSync,
+        scenePath: e == null ? void 0 : e.scenePath
+      }), this.thread.post({ sp: i });
+    }
+  }
+  clearWorkShapeNodeCache(e) {
+    var t;
+    (t = this.getWorkShape(e)) == null || t.clearTmpPoints(), this.workShapes.delete(e);
+  }
+  async drawBitMapEraserFull(e, t, s, r) {
+    const { willUpdateNodes: i, willDeleteNodes: o, eraseTxnRecoveryRequired: a } = t, n = e.getWorkId(), c = [
+      ...i ? Array.from(i.keys()).map((l) => String(l)) : [],
+      ...o ? Array.from(o) : []
+    ], d = [];
+    if (r && d.push({
+      type: h.None,
+      needUndoTicker: r,
+      undoScopeIds: c,
+      undoScopePhase: "finalize",
+      eraseTxnId: n,
+      eraseTxnRecoveryRequired: a
+    }), d.push({
+      type: h.RemoveNode,
+      removeIds: [n],
+      eraseTxnId: n,
+      viewId: this.thread.viewId,
+      needUndoTicker: r,
+      eraseTxnRecoveryRequired: a
+    }), s && d.push({
+      type: h.None,
+      isLockSentEventCursor: s
+    }), i != null && i.size || o != null && o.size) {
+      if (i != null && i.size)
+        for (const [l, p] of i)
+          d.push({
+            type: h.UpdateNode,
+            dataType: R.Local,
+            opt: p.opt,
+            workId: l,
+            updateNodeOpt: {
+              useAnimation: !1
+            },
+            eraseTxnId: n,
+            needUndoTicker: r
+          });
+      o != null && o.size && d.push({
+        type: h.RemoveNode,
+        removeIds: [...o],
+        eraseTxnId: n,
+        viewId: this.thread.viewId,
+        needUndoTicker: r
+      });
+    }
+    d.push({
+      type: h.None,
+      viewId: this.thread.viewId,
+      eraseTxnId: n,
+      eraseTxnPhase: t.eraseTxnCommitStatus === "failed" || a ? "failed" : "applied",
+      eraseTxnRecoveryRequired: a
+    }), d.length && this.thread.post({ sp: d });
+  }
+  drawPencilEraserFull(e, t, s, r) {
+    const { willNewNodes: i, willDeleteNodes: o } = t, a = e.getWorkId(), n = [
+      ...i ? Array.from(i.keys()).map((d) => String(d)) : [],
+      ...o ? Array.from(o) : []
+    ], c = [];
+    if (r && n.length && c.push({
+      type: h.None,
+      needUndoTicker: r,
+      undoScopeIds: n
+    }), c.push({
+      type: h.RemoveNode,
+      removeIds: [a],
+      viewId: this.thread.viewId,
+      needUndoTicker: r
+    }), s && c.push({
+      type: h.None,
+      isLockSentEventCursor: s
+    }), i != null && i.size || o != null && o.size) {
+      if (i != null && i.size)
+        for (const [d, l] of i)
+          c.push({
+            type: h.FullWork,
+            dataType: R.Local,
+            toolsType: l.toolsType,
+            ops: j(l.op),
+            opt: l.opt,
+            workId: d,
+            updateNodeOpt: {
+              useAnimation: !1
+            },
+            needUndoTicker: r
+          });
+      o != null && o.size && c.push({
+        type: h.RemoveNode,
+        removeIds: [...o],
+        viewId: this.thread.viewId,
+        needUndoTicker: r
+      });
+    }
+    c.length && this.thread.post({ sp: c });
+  }
+  drawEraser(e, t, s, r) {
+    const i = [], o = e.removeIds || [];
+    r && o.length && i.push({
+      type: h.None,
+      collectUndoTicker: r,
+      undoScopeIds: o,
+      undoScopePhase: "collect"
+    }), e.removeIds && i.push({ ...e, needUndoTicker: s, collectUndoTicker: r }), t && i.push({
+      type: h.None,
+      isLockSentEventCursor: t
+    }), s && i.push({
+      type: h.None,
+      needUndoTicker: s,
+      undoScopePhase: "finalize"
+    }), this.thread.post({ sp: i, consumeCount: this.consumeCount });
+  }
+  getWorkShape(e) {
+    return this.workShapes.get(e);
+  }
+  getWorkShapes() {
+    return this.workShapes;
+  }
+  async consumeDraw(e, t) {
+    const { op: s, workId: r, scenePath: i, postCount: o, smoothSync: a } = e;
+    if (s != null && s.length && r) {
+      const n = r.toString(), c = this.workShapes.get(n);
+      if (!c)
+        return;
+      const d = c.toolsType;
+      if (d === m.LaserPen)
+        return;
+      if (this.combineDrawActiveId && this.combineDrawActiveId !== n) {
+        const l = this.combineDrawActiveId;
+        this.eraserBatchScheduler.cancel(), this.combineDrawActiveId = void 0, await this.consumeDrawAll(
+          {
+            workId: l,
+            scenePath: i,
+            viewId: this.thread.viewId,
+            msgType: h.DrawWork,
+            dataType: R.Local
+          },
+          t
+        );
+      }
+      switch (this.drawWorkActiveId && this.drawWorkActiveId !== n && (await this.consumeDrawAll(
+        {
+          workId: this.drawWorkActiveId,
+          scenePath: i,
+          viewId: this.thread.viewId,
+          msgType: h.DrawWork,
+          dataType: R.Local
+        },
+        t
+      ), this.drawWorkActiveId = void 0), !this.drawWorkActiveId && n !== D && (this.drawWorkActiveId = n), G(o) && (this.consumeCount = o), d) {
+        case m.Selector: {
+          const l = c.consume({
+            data: e,
+            isFullWork: !0,
+            isMainThread: !0
+          });
+          this.fullWorkerDrawCount++;
+          const p = [];
+          l.type === h.Select && (l.selectIds && t.runReverseSelectWork(l.selectIds), p.push({ ...l, scenePath: i })), await this.thread.fullLayer.parent.prepareRender, this.thread.post({
+            consumeCount: this.consumeCount,
+            fullWorkerDrawCount: this.fullWorkerDrawCount,
+            sp: p
+          });
+          break;
+        }
+        case m.PencilEraser: {
+          c.consume({
+            data: e,
+            isFullWork: !1,
+            isMainThread: !0
+          }), this.fullWorkerDrawCount++, await this.thread.localLayer.parent.prepareRender, this.thread.post({
+            sp: void 0,
+            consumeCount: this.consumeCount,
+            fullWorkerDrawCount: this.fullWorkerDrawCount
+          }), this.combineDrawActiveId = n, this.eraserBatchScheduler.schedule(() => {
+            this.drawPencilEraserCombine(
+              n,
+              e.needUndoTicker,
+              e.collectUndoTicker
+            );
+          }, ge(this.thread.master.maxCombineEraserTime));
+          break;
+        }
+        case m.BitMapEraser: {
+          c.consume({
+            data: e,
+            isFullWork: !1,
+            isMainThread: !0
+          }), this.fullWorkerDrawCount++, this.combineDrawActiveId = n, await this.enqueueBitmapEraserRender(
+            n,
+            e.needUndoTicker,
+            e.collectUndoTicker,
+            {
+              consumeCount: this.consumeCount,
+              consumeWorkId: n
+            }
+          );
+          break;
+        }
+        case m.Eraser:
+          {
+            const l = c.consume({
+              data: e,
+              isFullWork: !0
+            });
+            await this.thread.fullLayer.parent.prepareRender, this.drawEraser(
+              l,
+              void 0,
+              e.needUndoTicker,
+              e.collectUndoTicker
+            );
+          }
+          break;
+        case m.Arrow:
+        case m.Straight:
+        case m.Ellipse:
+        case m.Rectangle:
+        case m.Star:
+        case m.Polygon:
+        case m.SpeechBalloon:
+        case m.Pencil:
+          {
+            const l = c.consume({
+              data: e,
+              isFullWork: !1,
+              isMainThread: !0,
+              smoothSync: a
+            });
+            l && (this.fullWorkerDrawCount++, await this.thread.localLayer.parent.prepareRender, this.thread.post({
+              consumeCount: this.consumeCount,
+              fullWorkerDrawCount: this.fullWorkerDrawCount,
+              sp: l.op && [{ ...l, scenePath: i }] || void 0
+            }));
+          }
+          break;
+      }
+    }
+  }
+  enqueueBitmapEraserRender(e, t, s, r) {
+    const i = this.bitmapEraserRenderQueue.then(async () => {
+      this.combineDrawActiveId !== e || !this.getWorkShape(e) || await this.postEraserBatch(
+        e,
+        t,
+        s,
+        r
+      );
+    });
+    return this.bitmapEraserRenderQueue = i.catch(() => {
+    }), i;
+  }
+  async drawPencilEraserCombine(e, t, s) {
+    await this.postEraserBatch(e, t, s);
+  }
+  async postEraserBatch(e, t, s, r) {
+    var o, a, n, c, d, l;
+    const i = (o = this.workShapes.get(e)) == null ? void 0 : o.combineConsume({ workerEngine: this });
+    if (i || r) {
+      const p = i == null ? void 0 : i.willDeleteNodes, f = i == null ? void 0 : i.willNewNodes, w = [
+        ...p ? Array.from(p) : []
+      ], k = {
+        render: [],
+        sp: [],
+        ...r
+      };
+      if (i != null && i.rect) {
+        const I = Te(i.rect);
+        (a = k.render) == null || a.push(
+          {
+            rect: I,
+            isClear: !0,
+            clearCanvas: re.Bg,
+            viewId: this.thread.viewId,
+            eraseTxnId: e
+          },
+          {
+            rect: I,
+            drawCanvas: re.Bg,
+            viewId: this.thread.viewId,
+            eraseTxnId: e
+          }
+        );
+      }
+      if (s && w.length && ((n = this.getWorkShape(e)) == null ? void 0 : n.toolsType) === m.BitMapEraser && ((c = k.sp) == null || c.push({
+        type: h.None,
+        collectUndoTicker: s,
+        undoScopeIds: w,
+        undoScopePhase: "collect"
+      })), p != null && p.size && ((d = k.sp) == null || d.push({
+        type: h.RemoveNode,
+        removeIds: [...p],
+        viewId: this.thread.viewId,
+        needUndoTicker: t,
+        collectUndoTicker: s
+      })), f != null && f.size)
+        for (const [I, W] of f)
+          (l = k.sp) == null || l.push({
+            type: h.FullWork,
+            dataType: R.Local,
+            toolsType: W.toolsType,
+            ops: j(W.op),
+            opt: W.opt,
+            workId: I,
+            updateNodeOpt: {
+              useAnimation: !1
+            },
+            needUndoTicker: t,
+            collectUndoTicker: s
+          });
+      i != null && i.rect && await this.thread.fullLayer.parent.prepareRender, this.thread.post(k);
+    }
+  }
+  async consumeDrawAll(e, t) {
+    var a, n, c;
+    this.eraserBatchScheduler.cancel();
+    const { workId: s, scenePath: r, isLockSentEventCursor: i } = e, o = e.needUndoTicker;
+    if (s) {
+      this.combineDrawActiveId === s.toString() && (this.combineDrawActiveId = void 0);
+      const d = s.toString();
+      this.drawWorkActiveId === d && (this.drawWorkActiveId = void 0);
+      const l = this.workShapes.get(d);
+      if (!l)
+        return;
+      const p = l.toolsType;
+      if (p === m.LaserPen)
+        return;
+      p === m.BitMapEraser && await this.bitmapEraserRenderQueue;
+      const f = this.workShapes.get(H), w = (a = f == null ? void 0 : f.selectIds) == null ? void 0 : a[0], k = await l.consumeAll({ data: e, workerEngine: this });
+      switch (p) {
+        case m.Selector:
+          {
+            k.selectIds && w && ((n = k.selectIds) != null && n.includes(w)) && f.cursorBlur();
+            const I = [];
+            i && I.push({
+              type: h.None,
+              isLockSentEventCursor: i,
+              scenePath: r
+            }), k.type === h.Select && (k.selectIds && t.runReverseSelectWork(k.selectIds), I.push({ ...k, scenePath: r })), I.length && this.thread.post({ sp: I }), (c = l.selectIds) != null && c.length ? l.clearTmpPoints() : this.clearWorkShapeNodeCache(d);
+          }
+          break;
+        case m.PencilEraser:
+          await this.drawPencilEraserFull(
+            l,
+            k,
+            i,
+            o
+          ), this.fullWorkerDrawCount = 0, this.clearWorkShapeNodeCache(d);
+          break;
+        case m.BitMapEraser:
+          await this.drawBitMapEraserFull(
+            l,
+            k,
+            i,
+            o
+          ), this.fullWorkerDrawCount = 0, this.clearWorkShapeNodeCache(d);
+          break;
+        case m.Eraser:
+          await this.drawEraser(
+            { ...k, scenePath: r },
+            i,
+            o,
+            e.collectUndoTicker
+          ), l.clearTmpPoints();
+          break;
+        case m.Arrow:
+        case m.Straight:
+        case m.Ellipse:
+        case m.Rectangle:
+        case m.Star:
+        case m.Polygon:
+        case m.SpeechBalloon:
+        case m.Pencil: {
+          const I = [];
+          if (i && I.push({
+            type: h.None,
+            isLockSentEventCursor: i,
+            scenePath: r
+          }), k) {
+            const g = p === m.Pencil && k.type === h.RemoveNode;
+            g ? $(
+              this.thread.localLayer,
+              this.thread.localLayer.parent
+            ) : I.push({
+              ...k,
+              scenePath: r,
+              needUndoTicker: e.needUndoTicker,
+              undoScopeIds: k.undoScopeIds || (k.workId !== void 0 ? [k.workId.toString()] : void 0),
+              undoScopePhase: k.undoScopePhase || "finalize"
+            }), this.fullWorkerDrawCount = 0, e.needUndoTicker && I.push({
+              type: h.None,
+              needUndoTicker: e.needUndoTicker,
+              scenePath: r,
+              undoScopeIds: g ? [] : void 0,
+              undoScopePhase: g ? "finalize" : void 0
+            }), (g ? this.thread.localLayer : this.thread.fullLayer).parent.prepareRender.then(() => {
+              this.thread.post({
+                fullWorkerDrawCount: this.fullWorkerDrawCount,
+                sp: I
+              });
+            });
+          }
+          this.clearWorkShapeNodeCache(d);
+          break;
+        }
+      }
+    }
+  }
+  getToolsOpt() {
+    return this.tmpOpt;
+  }
+  setToolsOpt(e) {
+    var t, s;
+    if ((t = this.tmpOpt) != null && t.toolsType && this.tmpOpt.toolsType !== e.toolsType) {
+      this.eraserBatchScheduler.cancel();
+      for (const [r, i] of this.workShapes)
+        r !== D && (i.clearTmpPoints(), this.workShapes.delete(r));
+    }
+    this.tmpOpt = e, (s = e.toolsOpt) != null && s.syncUnitTime && (this.syncUnitTime = e.toolsOpt.syncUnitTime);
+  }
+  setWorkOptions(e, t) {
+    let s = this.workShapes.get(e);
+    if (!s && this.tmpOpt) {
+      const { toolsType: r } = this.tmpOpt;
+      this.tmpOpt.toolsOpt = t, s = this.createWorkShapeNode({ workId: e, toolsType: r, toolsOpt: t }), s && this.workShapes.set(e, s), this.setToolsOpt(this.tmpOpt);
+    }
+    t.syncUnitTime || (t.syncUnitTime = this.syncUnitTime), s == null || s.setWorkOptions(t);
+  }
+  createWorkShapeNode(e) {
+    return Z(
+      {
+        ...e,
+        vNodes: this.vNodes,
+        fullLayer: this.thread.fullLayer,
+        drawLayer: this.thread.localLayer
+      },
+      this.thread.serviceWork
+    );
+  }
+}
+class Fe {
+  constructor(e) {
+    u(this, "vNodes");
+    u(this, "thread");
+    u(this, "workShapes", /* @__PURE__ */ new Map());
+    u(this, "selectorWorkShapes", /* @__PURE__ */ new Map());
+    u(this, "willRunEffectSelectorIds", /* @__PURE__ */ new Set());
+    u(this, "syncUnitTime", K.syncOpt.interval);
+    u(this, "animationScheduler");
+    u(this, "effectScheduler");
+    this.vNodes = e.vNodes, this.thread = e.thread, this.animationScheduler = new ie({
+      run: async () => {
+        try {
+          await this.animationDraw();
+        } catch (t) {
+          throw Y(t, {
+            business: "service-render",
+            stage: "animation-draw"
+          });
+        }
+      },
+      schedule: (t) => requestAnimationFrame(t),
+      cancel: (t) => cancelAnimationFrame(t),
+      onError: (t) => this.thread.reportRendererBusinessError(t, {
+        business: "service-render",
+        stage: "animation-draw"
+      })
+    }), this.effectScheduler = new ie({
+      run: async () => {
+        try {
+          await this.effectRunSelector();
+        } catch (t) {
+          throw Y(t, {
+            business: "service-render",
+            stage: "selector-effect"
+          });
+        }
+      },
+      schedule: (t) => setTimeout(t, 0),
+      cancel: (t) => clearTimeout(t),
+      onError: (t) => this.thread.reportRendererBusinessError(t, {
+        business: "service-render",
+        stage: "selector-effect"
+      })
+    });
+  }
+  async loadImageBitMap(e) {
+    return await this.thread.loadImageBitMap(e);
+  }
+  destroy() {
+    this.animationScheduler.destroy(), this.effectScheduler.destroy(), this.clearAll();
+  }
+  clearAll() {
+    this.thread.serviceLayer.children.length && (this.thread.serviceLayer.parent.children.forEach((e) => {
+      e.name !== "viewport" && e.remove();
+    }), $(
+      this.thread.serviceLayer,
+      this.thread.serviceLayer.parent
+    )), this.workShapes.clear(), this.selectorWorkShapes.clear(), this.willRunEffectSelectorIds.clear();
+  }
+  runEffect() {
+    this.effectScheduler.request();
+  }
+  effectRunSelector() {
+    this.willRunEffectSelectorIds.forEach((e) => {
+      var s, r;
+      const t = this.selectorWorkShapes.get(e);
+      t && t.selectIds && ((s = t.node) == null || s.selectServiceNode(
+        e,
+        t,
+        !0
+      )), (r = t == null ? void 0 : t.selectIds) != null && r.length || this.selectorWorkShapes.delete(e);
+    }), this.willRunEffectSelectorIds.clear();
+  }
+  runSelectWork(e) {
+    this.activeSelectorShape(e);
+    const { workId: t } = e, s = t == null ? void 0 : t.toString();
+    s && this.willRunEffectSelectorIds.add(s), this.runEffect();
+  }
+  removeWork(e) {
+    const { workId: t } = e, s = t == null ? void 0 : t.toString();
+    if (s) {
+      if (this.workShapes.get(s)) {
+        this.workShapes.delete(s), this.removeNode(s, e);
+        return;
+      }
+      this.removeNode(s, e);
+    }
+  }
+  consumeFull(e) {
+    if (this.activeWorkShape(e), e.refreshTextRender) {
+      this.runAnimation(!0);
+      return;
+    }
+    this.runAnimation();
+  }
+  runReverseSelectWork(e) {
+    e.forEach((t) => {
+      this.selectorWorkShapes.forEach((s, r) => {
+        var i;
+        if ((i = s.selectIds) != null && i.length) {
+          const o = s.selectIds.indexOf(t);
+          o > -1 && (s.selectIds.splice(o, 1), this.willRunEffectSelectorIds.add(r));
+        }
+      });
+    }), this.willRunEffectSelectorIds.size && this.runEffect();
+  }
+  consumeDraw(e) {
+    this.activeWorkShape(e), this.runAnimation();
+  }
+  computNextAnimationIndex(e, t) {
+    const s = Math.floor(
+      (e.animationWorkData || []).slice(e.animationIndex).length * 32 / t / this.syncUnitTime
+    ) * t;
+    return Math.min(
+      (e.animationIndex || 0) + (s || t),
+      (e.animationWorkData || []).length
+    );
+  }
+  async animationDraw() {
+    var r, i, o, a, n, c, d, l, p, f, w, k, I, W, g, y, S, T, C, L, A;
+    let e = !1;
+    const t = /* @__PURE__ */ new Map(), s = [];
+    for (const [E, v] of this.workShapes.entries())
+      switch (v.toolsType) {
+        case m.BackgroundSVG: {
+          (r = v.node) == null || r.consumeService({
+            isFullWork: !0,
+            replaceId: E
+          }), this.selectorWorkShapes.forEach((O, B) => {
+            var P;
+            (P = O.selectIds) != null && P.includes(E) && (this.willRunEffectSelectorIds.add(B), this.runEffect());
+          }), this.workShapes.delete(E);
+          break;
+        }
+        case m.Image: {
+          await ((i = v.node) == null ? void 0 : i.consumeServiceAsync({
+            isFullWork: !0,
+            worker: this
+          })), this.selectorWorkShapes.forEach((O, B) => {
+            var P;
+            (P = O.selectIds) != null && P.includes(E) && (this.willRunEffectSelectorIds.add(B), this.runEffect());
+          }), this.workShapes.delete(E);
+          break;
+        }
+        case m.Text: {
+          v.node && (await ((o = v.node) == null ? void 0 : o.consumeServiceAsync({
+            isFullWork: !0,
+            replaceId: E,
+            boxRect: this.thread.getSceneRect()
+          })), this.selectorWorkShapes.forEach((O, B) => {
+            var P;
+            (P = O.selectIds) != null && P.includes(E) && (this.willRunEffectSelectorIds.add(B), this.runEffect());
+          }), v.refreshTextRender && v.requestId && s.push({
+            type: h.RefreshTextRender,
+            requestId: v.requestId,
+            workId: E,
+            viewId: this.thread.viewId
+          }), (a = v.node) == null || a.clearTmpPoints(), this.workShapes.delete(E));
+          break;
+        }
+        case m.Arrow:
+        case m.Straight:
+        case m.Rectangle:
+        case m.Ellipse:
+        case m.Star:
+        case m.Polygon:
+        case m.SpeechBalloon: {
+          const O = !!v.ops;
+          if ((n = v.animationWorkData) != null && n.length) {
+            const B = v.oldRect;
+            (c = v.node) == null || c.consumeService({
+              op: v.animationWorkData,
+              isFullWork: O
+            }), O && (this.selectorWorkShapes.forEach((P, F) => {
+              var U;
+              (U = P.selectIds) != null && U.includes(E) && (this.willRunEffectSelectorIds.add(F), this.runEffect());
+            }), (d = v.node) == null || d.clearTmpPoints(), this.workShapes.delete(E)), v.isEnableCursor ? t.set(E, {
+              cursorTool: _(v.toolsType),
+              workState: B ? v.ops ? b.Done : b.Doing : b.Start,
+              op: v.animationWorkData.slice(-3, -1)
+            }) : O && !v.useAnimation && ((l = v.updateNodeOpt) != null && l.useAnimation) && t.set(E, {
+              cursorTool: _(v.toolsType),
+              workState: b.Done,
+              op: v.animationWorkData.slice(-3, -1),
+              uid: (p = v.updateNodeOpt) == null ? void 0 : p.uid
+            }), v.animationWorkData.length = 0;
+          }
+          break;
+        }
+        case m.Pencil: {
+          if (v.useAnimation) {
+            if (v.useAnimation) {
+              if (v.isDel) {
+                (y = v.node) == null || y.clearTmpPoints(), this.workShapes.delete(E);
+                break;
+              }
+              const O = 3, B = this.computNextAnimationIndex(
+                v,
+                O
+              ), P = v.isDiff ? 0 : Math.max(0, (v.animationIndex || 0) - O), F = (v.animationWorkData || []).slice(
+                P,
+                B
+              ), U = (T = (S = v.node) == null ? void 0 : S.getWorkId()) == null ? void 0 : T.toString();
+              if ((v.animationIndex || 0) < B || v.isDiff) {
+                if ((C = v.node) == null || C.consumeService({
+                  op: F,
+                  isFullWork: !1
+                }), v.animationIndex = B, v.isDiff && (v.isDiff = !1), F.length && v.isEnableCursor) {
+                  const X = F.slice(-3, -1);
+                  t.set(E, {
+                    cursorTool: _(v.toolsType),
+                    workState: P === 0 ? b.Start : B === ((L = v.animationWorkData) == null ? void 0 : L.length) ? b.Done : b.Doing,
+                    op: X
+                  });
+                }
+              } else v.ops && ((A = v.node) == null || A.consumeService({
+                op: v.animationWorkData || [],
+                isFullWork: !0,
+                replaceId: U
+              }), v.isDel = !0, v.isEnableCursor && t.set(E, {
+                cursorTool: _(v.toolsType),
+                workState: b.Done,
+                op: F.slice(-3, -1)
+              }));
+              e = !0;
+              break;
+            }
+          } else {
+            const O = !!v.ops;
+            if ((f = v.node) == null || f.consumeService({
+              op: v.animationWorkData || [],
+              isFullWork: O,
+              replaceId: E
+            }), (w = v.node) == null || w.updataOptService(v.updateNodeOpt), O) {
+              if (!v.isEnableCursor && ((k = v.updateNodeOpt) != null && k.useAnimation) && ((I = v.animationWorkData) != null && I.length)) {
+                const B = v.animationWorkData.slice(-3, -1);
+                t.set(E, {
+                  cursorTool: _(v.toolsType),
+                  workState: b.Done,
+                  op: B,
+                  uid: (W = v.updateNodeOpt) == null ? void 0 : W.uid
+                });
+              }
+              this.selectorWorkShapes.forEach((B, P) => {
+                var F;
+                (F = B.selectIds) != null && F.includes(E) && (this.willRunEffectSelectorIds.add(P), this.runEffect());
+              }), (g = v.node) == null || g.clearTmpPoints(), this.workShapes.delete(E);
+            }
+          }
+          break;
+        }
+      }
+    e && this.runAnimation(), t.size && t.forEach((E, v) => {
+      s.push({
+        type: h.Cursor,
+        uid: E.uid || v.split(de)[0],
+        op: E.op,
+        workState: E.workState,
+        cursorTool: E.cursorTool,
+        viewId: this.thread.viewId
+      });
+    }), s.length && this.thread.post({ sp: s });
+  }
+  runAnimation(e = !1) {
+    this.animationScheduler.request(e);
+  }
+  async flush() {
+    await this.animationScheduler.flush(), await this.effectScheduler.flush();
+  }
+  hasDiffData(e, t, s) {
+    const r = e.length;
+    if (t.length < r)
+      return !0;
+    switch (s) {
+      case m.Pencil: {
+        for (let i = 0; i < r; i += 3)
+          if (t[i] !== e[i] || t[i + 1] !== e[i + 1])
+            return !0;
+        break;
+      }
+      case m.LaserPen: {
+        for (let i = 0; i < r; i += 2)
+          if (t[i] !== e[i] || t[i + 1] !== e[i + 1])
+            return !0;
+        break;
+      }
+    }
+    return !1;
+  }
+  activeWorkShape(e) {
+    var W, g, y, S;
+    const {
+      workId: t,
+      opt: s,
+      toolsType: r,
+      type: i,
+      updateNodeOpt: o,
+      ops: a,
+      op: n,
+      useAnimation: c,
+      imageBitmap: d,
+      isEnableCursor: l,
+      requestId: p,
+      refreshTextRender: f
+    } = e;
+    if (!t)
+      return;
+    const w = t.toString(), k = (W = this.vNodes.get(w)) == null ? void 0 : W.rect;
+    if (!((g = this.workShapes) != null && g.has(w))) {
+      let T = {
+        toolsType: r,
+        animationWorkData: n || [],
+        animationIndex: 0,
+        type: i,
+        updateNodeOpt: o,
+        ops: a,
+        useAnimation: typeof c < "u" ? c : typeof (o == null ? void 0 : o.useAnimation) < "u" ? o == null ? void 0 : o.useAnimation : !0,
+        oldRect: k,
+        isDiff: !1,
+        imageBitmap: d,
+        isEnableCursor: l
+      };
+      r && s && (T = this.setNodeKey(w, T, r, s)), (y = this.workShapes) == null || y.set(w, T);
+    }
+    const I = (S = this.workShapes) == null ? void 0 : S.get(w);
+    I.isEnableCursor = l, I.requestId = p, I.refreshTextRender = !!f, i && (I.type = i), a && (I.animationWorkData = V(a), I.ops = a), o && (I.updateNodeOpt = o), n && (I.isDiff = this.hasDiffData(
+      I.animationWorkData || [],
+      n,
+      I.toolsType
+    ), I.toolsType, m.Pencil, I.animationWorkData = n), I.node && I.node.getWorkId() !== w && I.node.setWorkId(w), k && (I.oldRect = k), r && s && (s.syncUnitTime && (this.syncUnitTime = s.syncUnitTime), I.toolsType !== r && r && s && this.setNodeKey(w, I, r, s), I.node && I.node.setWorkOptions(s)), d && (I.imageBitmap = d);
+  }
+  removeNode(e, t) {
+    e.indexOf(D) > -1 && this.removeSelectWork(t), this.thread.fullLayer.getElementsByName(e).forEach((r) => {
+      r.remove(), z(r, this.thread.fullLayer.parent);
+    }), this.thread.serviceLayer.getElementsByName(e).forEach((r) => {
+      r.remove(), z(r, this.thread.serviceLayer.parent);
+    });
+    const s = this.vNodes.get(e);
+    s && s.toolsType === m.BackgroundSVG && this.thread.post({
+      sp: [
+        {
+          type: h.BackgroundSVGDelete,
+          toolsType: m.BackgroundSVG,
+          workId: e,
+          dataType: R.Service,
+          viewId: this.thread.viewId
+        }
+      ]
+    }), this.vNodes.delete(e);
+  }
+  removeSelectWork(e) {
+    const { workId: t } = e, s = t == null ? void 0 : t.toString();
+    s && (this.activeSelectorShape(e), this.willRunEffectSelectorIds.add(s)), this.runEffect();
+  }
+  activeSelectorShape(e) {
+    var c, d, l;
+    const { workId: t, opt: s, toolsType: r, type: i, selectIds: o } = e;
+    if (!t)
+      return;
+    const a = t.toString();
+    if (!((c = this.selectorWorkShapes) != null && c.has(a))) {
+      let p = {
+        toolsType: r,
+        selectIds: o,
+        type: i,
+        opt: s
+      };
+      r && s && (p = this.setNodeKey(a, p, r, s)), (d = this.selectorWorkShapes) == null || d.set(a, p);
+    }
+    const n = (l = this.selectorWorkShapes) == null ? void 0 : l.get(a);
+    i && (n.type = i), n.node && n.node.getWorkId() !== a && n.node.setWorkId(a), n.selectIds = o || [];
+  }
+  setNodeKey(e, t, s, r) {
+    return t.toolsType = s, t.node = Z(
+      {
+        toolsType: s,
+        toolsOpt: r,
+        vNodes: this.vNodes,
+        fullLayer: this.thread.fullLayer,
+        drawLayer: this.thread.serviceLayer,
+        workId: e
+      },
+      this
+    ), t;
+  }
+}
+class x {
+  constructor() {
+    u(this, "localWork");
+    u(this, "serviceWork");
+    u(this, "threadEngine");
+  }
+  registerMainThread(e) {
+    return this.threadEngine = e, this.localWork = e.localWork, this.serviceWork = e.serviceWork, this;
+  }
+}
+class Ue extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.CopyNode);
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.FullWork && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var r;
+    const { workId: s } = t;
+    s && await ((r = this.localWork) == null ? void 0 : r.consumeFull(t));
+  }
+}
+class xe extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.SetColorNode);
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var l;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      textUpdateForWoker: n,
+      needUndoTicker: c,
+      requestId: d
+    } = t;
+    s === D && r && await ((l = this.localWork) == null ? void 0 : l.updateSelector({
+      updateSelectorOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      emitEventType: this.emitEventType,
+      requestId: d,
+      textUpdateForWoker: n,
+      callback: this.updateSelectorCallback,
+      needUndoTicker: c
+    }));
+  }
+  updateSelectorCallback(t) {
+    const { param: s, postData: r, newServiceStore: i } = t, {
+      willSyncService: o,
+      isSync: a,
+      textUpdateForWoker: n,
+      needUndoTicker: c,
+      requestId: d,
+      emitEventType: l
+    } = s, p = r.sp || [];
+    if (o)
+      for (const [f, w] of i.entries())
+        n && w.toolsType === m.Text ? p.push({
+          ...w,
+          workId: f,
+          type: h.TextUpdate,
+          dataType: R.Local,
+          willSyncService: !0,
+          emitEventType: l,
+          requestId: d,
+          needUndoTicker: c
+        }) : p.push({
+          ...w,
+          workId: f,
+          type: h.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: a,
+          emitEventType: l,
+          requestId: d,
+          needUndoTicker: c
+        });
+    return c && p.push({
+      type: h.None,
+      needUndoTicker: c
+    }), {
+      sp: p
+    };
+  }
+}
+class Ge extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.ZIndexNode);
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var d;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      needUndoTicker: n,
+      requestId: c
+    } = t;
+    s === D && r && await ((d = this.localWork) == null ? void 0 : d.updateSelector({
+      updateSelectorOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      emitEventType: this.emitEventType,
+      requestId: c,
+      callback: this.updateSelectorCallback,
+      needUndoTicker: n
+    }));
+  }
+  updateSelectorCallback(t) {
+    const { param: s, postData: r, newServiceStore: i } = t, {
+      willSyncService: o,
+      isSync: a,
+      needUndoTicker: n,
+      requestId: c,
+      emitEventType: d
+    } = s, l = r.sp || [];
+    if (o && l)
+      for (const [p, f] of i.entries())
+        f.toolsType === m.BackgroundSVG && l.push({
+          ...f,
+          workId: p,
+          type: h.BackgroundSVGUpdate,
+          dataType: R.Local,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          needUndoTicker: n,
+          emitEventType: d,
+          requestId: c
+        }), l.push({
+          ...f,
+          workId: p,
+          type: h.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: a,
+          emitEventType: d,
+          requestId: c,
+          needUndoTicker: n
+        });
+    return n && l.push({
+      type: h.None,
+      needUndoTicker: n
+    }), {
+      sp: l
+    };
+  }
+}
+class qe extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.TranslateNode);
+    u(this, "updateSelectorCallback", (t) => {
+      var W;
+      const { param: s, postData: r, newServiceStore: i, workShapeNode: o, res: a, smoothSync: n } = t, {
+        willSyncService: c,
+        isSync: d,
+        updateSelectorOpt: l,
+        textUpdateForWoker: p,
+        needUndoTicker: f
+      } = s, w = l.workState, k = r.sp || [];
+      if (w === b.Start)
+        return {
+          sp: [
+            {
+              type: h.SelectorTransform,
+              emitEventType: this.emitEventType,
+              workState: w
+            }
+          ],
+          render: []
+        };
+      const I = a == null ? void 0 : a.selectRect;
+      if (c) {
+        const g = w === b.Done ? f : void 0;
+        k.push({
+          type: h.Select,
+          selectIds: o.selectIds,
+          selectRect: I,
+          willSyncService: w === b.Done ? !0 : n,
+          isSync: !0,
+          points: w === b.Done && o.getChildrenPoints() || void 0,
+          textOpt: o.textOpt,
+          needUndoTicker: g,
+          emitEventType: this.emitEventType
+        });
+        const y = {
+          workState: w,
+          useAnimation: l.useAnimation || !1
+        };
+        l.uid && (y.uid = l.uid);
+        for (const [S, T] of i.entries())
+          T.toolsType === m.BackgroundSVG && k.push({
+            ...T,
+            workId: S,
+            type: h.BackgroundSVGUpdate,
+            dataType: R.Local,
+            willSyncService: w === b.Done ? !0 : n,
+            updateNodeOpt: y,
+            needUndoTicker: g,
+            emitEventType: this.emitEventType
+          }), p && T.toolsType === m.Text ? k.push({
+            ...T,
+            workId: S,
+            type: h.TextUpdate,
+            dataType: R.Local,
+            willSyncService: w === b.Done ? !0 : n,
+            updateNodeOpt: y,
+            needUndoTicker: g,
+            emitEventType: this.emitEventType
+          }) : (n || w === b.Done) && k.push({
+            ...T,
+            workId: S,
+            type: h.UpdateNode,
+            updateNodeOpt: {
+              ...y,
+              eraserGeometryDelta: ee(
+                (W = this.localWork) == null ? void 0 : W.vNodes,
+                S
+              )
+            },
+            isSync: d,
+            needUndoTicker: g,
+            emitEventType: this.emitEventType
+          });
+      }
+      return f && k.push({
+        type: h.None,
+        needUndoTicker: f
+      }), k.push({
+        type: h.SelectorTransform,
+        emitEventType: this.emitEventType,
+        workState: w
+      }), {
+        sp: k
+      };
+    });
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var p, f;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      textUpdateForWoker: n,
+      emitEventType: c,
+      smoothSync: d,
+      needUndoTicker: l
+    } = t;
+    s === D && r && (r.workState === b.Done && (r != null && r.translate) && (r.translate[0] || r.translate[1]) || r.workState !== b.Done ? await ((p = this.localWork) == null ? void 0 : p.updateSelector({
+      updateSelectorOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      isSync: !0,
+      textUpdateForWoker: n,
+      emitEventType: c,
+      callback: this.updateSelectorCallback,
+      smoothSync: d,
+      needUndoTicker: l
+    })) : r.workState === b.Done && ((f = this.localWork) == null || f.vNodes.deleteLastTarget()));
+  }
+}
+class ze extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.ScaleNode);
+    u(this, "updateSelectorCallback", (t) => {
+      var I;
+      const { param: s, postData: r, workShapeNode: i, res: o, newServiceStore: a, smoothSync: n } = t, { updateSelectorOpt: c, willSyncService: d, needUndoTicker: l } = s, p = c.workState, f = r.sp || [], w = o == null ? void 0 : o.selectRect, k = p === b.Done ? l : void 0;
+      if (p === b.Start)
+        return {
+          sp: [
+            {
+              type: h.SelectorTransform,
+              emitEventType: this.emitEventType,
+              workState: p
+            }
+          ],
+          render: []
+        };
+      if (d) {
+        f.push({
+          type: h.Select,
+          selectIds: i.selectIds,
+          selectRect: w,
+          willSyncService: p === b.Done ? !0 : n,
+          isSync: !0,
+          points: p === b.Done && i.getChildrenPoints() || void 0,
+          textOpt: i.textOpt
+        });
+        const W = {
+          useAnimation: c.useAnimation || !1
+        };
+        c.uid && (W.uid = c.uid);
+        for (const [g, y] of a.entries())
+          y.toolsType === m.BackgroundSVG && f.push({
+            ...y,
+            workId: g,
+            type: h.BackgroundSVGUpdate,
+            dataType: R.Local,
+            willSyncService: p === b.Done ? !0 : n,
+            updateNodeOpt: W,
+            needUndoTicker: k,
+            emitEventType: this.emitEventType
+          }), y.toolsType === m.Text ? f.push({
+            ...y,
+            workId: g,
+            type: h.TextUpdate,
+            dataType: R.Local,
+            willSyncService: p === b.Done ? !0 : n,
+            updateNodeOpt: W,
+            needUndoTicker: k,
+            emitEventType: this.emitEventType
+          }) : (n || p === b.Done) && f.push({
+            ...y,
+            workId: g,
+            type: h.UpdateNode,
+            updateNodeOpt: {
+              ...W,
+              eraserGeometryDelta: ee(
+                (I = this.localWork) == null ? void 0 : I.vNodes,
+                g
+              )
+            },
+            isSync: !0,
+            needUndoTicker: k,
+            emitEventType: this.emitEventType
+          });
+      }
+      return l && f.push({
+        type: h.None,
+        needUndoTicker: l
+      }), f.push({
+        type: h.SelectorTransform,
+        emitEventType: this.emitEventType,
+        workState: p
+      }), {
+        sp: f
+      };
+    });
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var c;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willSyncService: i,
+      willSerializeData: o,
+      smoothSync: a,
+      needUndoTicker: n
+    } = t;
+    s === D && r && await ((c = this.localWork) == null ? void 0 : c.updateSelector({
+      updateSelectorOpt: r,
+      willSyncService: i,
+      willSerializeData: o,
+      isSync: !0,
+      callback: this.updateSelectorCallback.bind(this),
+      smoothSync: a,
+      needUndoTicker: n
+    }));
+  }
+}
+class Ve extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.RotateNode);
+    u(this, "updateSelectorCallback", (t) => {
+      var g;
+      const { param: s, postData: r, workShapeNode: i, res: o, newServiceStore: a, smoothSync: n } = t, {
+        updateSelectorOpt: c,
+        willSyncService: d,
+        willSerializeData: l,
+        isSync: p,
+        needUndoTicker: f
+      } = s, w = c.workState, k = r.sp || [], I = o == null ? void 0 : o.selectRect, W = w === b.Done ? f : void 0;
+      if (d) {
+        l && w === b.Done && k.push({
+          type: h.Select,
+          selectIds: i.selectIds,
+          selectRect: I,
+          willSyncService: w === b.Done ? !0 : n,
+          isSync: p,
+          points: i.getChildrenPoints()
+        });
+        const y = {
+          useAnimation: c.useAnimation || !1
+        };
+        if (c.uid && (y.uid = c.uid), n || w === b.Done)
+          for (const [S, T] of a.entries())
+            k.push({
+              ...T,
+              workId: S,
+              type: h.UpdateNode,
+              updateNodeOpt: {
+                ...y,
+                eraserGeometryDelta: ee(
+                  (g = this.localWork) == null ? void 0 : g.vNodes,
+                  S
+                )
+              },
+              isSync: p,
+              needUndoTicker: W,
+              emitEventType: this.emitEventType
+            });
+      }
+      return f && k.push({
+        type: h.None,
+        needUndoTicker: f
+      }), k.push({
+        type: h.SelectorTransform,
+        emitEventType: this.emitEventType,
+        workState: w
+      }), {
+        sp: k
+      };
+    });
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var l;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      emitEventType: n,
+      smoothSync: c,
+      needUndoTicker: d
+    } = t;
+    s === D && r && await ((l = this.localWork) == null ? void 0 : l.updateSelector({
+      updateSelectorOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      emitEventType: n,
+      isSync: !0,
+      callback: this.updateSelectorCallback,
+      smoothSync: c,
+      needUndoTicker: d
+    }));
+  }
+}
+class $e extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.SetFontStyle);
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var d;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      textUpdateForWoker: n,
+      requestId: c
+    } = t;
+    s === D && r && await ((d = this.localWork) == null ? void 0 : d.updateSelector({
+      updateSelectorOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      emitEventType: this.emitEventType,
+      requestId: c,
+      textUpdateForWoker: n,
+      callback: this.updateSelectorCallback
+    }));
+  }
+  updateSelectorCallback(t) {
+    const { param: s, postData: r, newServiceStore: i, workShapeNode: o, res: a } = t, {
+      willSyncService: n,
+      isSync: c,
+      updateSelectorOpt: d,
+      textUpdateForWoker: l,
+      requestId: p,
+      emitEventType: f
+    } = s, w = r.sp || [], k = a == null ? void 0 : a.selectRect;
+    if (n && w) {
+      d.fontSize && w.push({
+        type: h.Select,
+        selectIds: o.selectIds,
+        selectRect: k,
+        willSyncService: n,
+        isSync: c,
+        points: o.getChildrenPoints()
+      });
+      for (const [I, W] of i.entries())
+        l && W.toolsType === m.Text ? w.push({
+          ...W,
+          workId: I,
+          type: h.TextUpdate,
+          dataType: R.Local,
+          willSyncService: !0,
+          emitEventType: f,
+          requestId: p
+        }) : w.push({
+          ...W,
+          workId: I,
+          type: h.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: c,
+          emitEventType: f,
+          requestId: p
+        });
+    }
+    return {
+      sp: w
+    };
+  }
+}
+class _e extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.SetPoint);
+    u(this, "updateSelectorCallback", (t) => {
+      const { param: s, postData: r, newServiceStore: i, workShapeNode: o, res: a } = t, { willSyncService: n, isSync: c, needUndoTicker: d } = s, l = r.sp || [], p = a == null ? void 0 : a.selectRect;
+      if (n && l) {
+        for (const [f, w] of i.entries())
+          l.push({
+            ...w,
+            workId: f,
+            type: h.UpdateNode,
+            updateNodeOpt: {
+              useAnimation: !1
+            },
+            isSync: c,
+            needUndoTicker: d,
+            emitEventType: this.emitEventType
+          });
+        l.push({
+          type: h.Select,
+          selectIds: o.selectIds,
+          selectRect: p,
+          willSyncService: n,
+          isSync: c,
+          points: o.getChildrenPoints()
+        });
+      }
+      return d && l.push({
+        type: h.None,
+        needUndoTicker: d
+      }), l.push({
+        type: h.SelectorTransform,
+        emitEventType: this.emitEventType,
+        workState: s.updateSelectorOpt.workState
+      }), {
+        sp: l
+      };
+    });
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var d;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      textUpdateForWoker: n,
+      needUndoTicker: c
+    } = t;
+    s === D && r && await ((d = this.localWork) == null ? void 0 : d.updateSelector({
+      updateSelectorOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      emitEventType: this.emitEventType,
+      willSerializeData: a,
+      isSync: !0,
+      textUpdateForWoker: n,
+      callback: this.updateSelectorCallback,
+      needUndoTicker: c
+    }));
+  }
+}
+class He extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.SetLock);
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var d;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      needUndoTicker: n,
+      requestId: c
+    } = t;
+    s === D && r && await ((d = this.localWork) == null ? void 0 : d.updateSelector({
+      updateSelectorOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      emitEventType: this.emitEventType,
+      requestId: c,
+      callback: this.updateSelectorCallback,
+      needUndoTicker: n
+    }));
+  }
+  updateSelectorCallback(t) {
+    const { param: s, postData: r, newServiceStore: i, workShapeNode: o, res: a } = t, {
+      willSyncService: n,
+      isSync: c,
+      updateSelectorOpt: d,
+      needUndoTicker: l,
+      requestId: p,
+      emitEventType: f
+    } = s, w = r.sp || [], k = a == null ? void 0 : a.selectRect;
+    if (n && w) {
+      for (const [I, W] of i.entries())
+        w.push({
+          ...W,
+          workId: I,
+          type: h.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: c,
+          emitEventType: f,
+          requestId: p
+        });
+      w.push({
+        isLocked: d.isLocked,
+        selectorColor: o.selectorColor,
+        scaleType: o.scaleType,
+        canRotate: o.canRotate,
+        type: h.Select,
+        selectIds: o.selectIds,
+        selectRect: k,
+        willSyncService: n,
+        isSync: c
+      });
+    }
+    return l && w.push({
+      type: h.None,
+      needUndoTicker: l
+    }), {
+      sp: w
+    };
+  }
+}
+class Qe extends x {
+  constructor() {
+    super(...arguments);
+    u(this, "emitEventType", N.SetShapeOpt);
+  }
+  async consume(t) {
+    const { msgType: s, dataType: r, emitEventType: i } = t;
+    if (s === h.UpdateNode && r === R.Local && i === this.emitEventType)
+      return await this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var d;
+    const {
+      workId: s,
+      updateNodeOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      needUndoTicker: n,
+      requestId: c
+    } = t;
+    s === D && r && await ((d = this.localWork) == null ? void 0 : d.updateSelector({
+      updateSelectorOpt: r,
+      willRefreshSelector: i,
+      willSyncService: o,
+      willSerializeData: a,
+      emitEventType: this.emitEventType,
+      requestId: c,
+      callback: this.updateSelectorCallback,
+      needUndoTicker: n
+    }));
+  }
+  updateSelectorCallback(t) {
+    const { param: s, postData: r, newServiceStore: i } = t, {
+      willSyncService: o,
+      isSync: a,
+      needUndoTicker: n,
+      requestId: c,
+      emitEventType: d
+    } = s, l = r.sp || [];
+    if (o && l)
+      for (const [p, f] of i.entries())
+        l.push({
+          ...f,
+          workId: p,
+          type: h.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: a,
+          emitEventType: d,
+          requestId: c
+        });
+    return n && l.push({
+      type: h.None,
+      needUndoTicker: n
+    }), {
+      sp: l
+    };
+  }
+}
+class Ke {
+  constructor(e) {
+    u(this, "builders", /* @__PURE__ */ new Map());
+    this.builders = new Map(e.map((t) => [t, this.build(t)]));
+  }
+  build(e) {
+    switch (e) {
+      case N.TranslateNode:
+        return new qe();
+      case N.ZIndexNode:
+        return new Ge();
+      case N.CopyNode:
+        return new Ue();
+      case N.SetColorNode:
+        return new xe();
+      case N.ScaleNode:
+        return new ze();
+      case N.RotateNode:
+        return new Ve();
+      case N.SetFontStyle:
+        return new $e();
+      case N.SetPoint:
+        return new _e();
+      case N.SetLock:
+        return new He();
+      case N.SetShapeOpt:
+        return new Qe();
+    }
+  }
+  registerForMainThread(e) {
+    return this.builders.forEach((t) => {
+      t && t.registerMainThread(e);
+    }), this;
+  }
+  async consumeForMainThread(e) {
+    for (const t of this.builders.values())
+      if (await (t == null ? void 0 : t.consume(e)))
+        return !0;
+    return !1;
+  }
+}
+function Xe({
+  subThreads: M,
+  layers: e,
+  scene: t,
+  removeLayerTexture: s
+}) {
+  let r;
+  for (const i of M)
+    try {
+      i.destroy();
+    } catch (o) {
+      r || (r = o);
+    }
+  for (const i of e) {
+    const o = i.parent;
+    if (o)
+      try {
+        s(i, o);
+      } catch (a) {
+        r || (r = a);
+      }
+    try {
+      i.remove();
+    } catch (a) {
+      r || (r = a);
+    }
+  }
+  try {
+    t.remove();
+  } catch (i) {
+    r || (r = i);
+  }
+  if (r)
+    throw r;
+}
+const Ye = 4;
+class Ze {
+  constructor(e = {}) {
+    u(this, "pendingFrames", /* @__PURE__ */ new Map());
+    u(this, "failedCanvases", /* @__PURE__ */ new Set());
+    u(this, "tailFrameCount");
+    u(this, "requestFrame");
+    u(this, "cancelFrame");
+    u(this, "onReadbackError");
+    u(this, "frameHandle");
+    u(this, "destroyed", !1);
+    this.tailFrameCount = Math.max(
+      1,
+      Math.floor(e.tailFrameCount ?? Ye)
+    ), this.requestFrame = e.requestFrame ?? ((t) => requestAnimationFrame(t)), this.cancelFrame = e.cancelFrame ?? ((t) => cancelAnimationFrame(t)), this.onReadbackError = e.onReadbackError;
+  }
+  markRendered(e) {
+    this.destroyed || (this.pendingFrames.set(e, this.tailFrameCount), this.schedule());
+  }
+  destroy() {
+    this.destroyed || (this.destroyed = !0, this.frameHandle !== void 0 && (this.cancelFrame(this.frameHandle), this.frameHandle = void 0), this.pendingFrames.clear(), this.failedCanvases.clear());
+  }
+  schedule() {
+    this.destroyed || this.frameHandle !== void 0 || this.pendingFrames.size === 0 || (this.frameHandle = this.requestFrame(() => this.flushFrame()));
+  }
+  flushFrame() {
+    var e, t;
+    if (this.frameHandle = void 0, !this.destroyed) {
+      for (const [s, r] of this.pendingFrames) {
+        if (!s.isConnected || s.width <= 0 || s.height <= 0) {
+          this.pendingFrames.delete(s);
+          continue;
+        }
+        try {
+          (e = s.getContext("2d")) == null || e.getImageData(0, 0, 1, 1);
+        } catch (i) {
+          this.failedCanvases.has(s) || (this.failedCanvases.add(s), (t = this.onReadbackError) == null || t.call(this, i));
+        }
+        r <= 1 ? this.pendingFrames.delete(s) : this.pendingFrames.set(s, r - 1);
+      }
+      this.schedule();
+    }
+  }
+}
+class je {
+  constructor(e, t) {
+    u(this, "viewId");
+    u(this, "fullLayer");
+    u(this, "topLayer");
+    u(this, "localLayer");
+    u(this, "serviceLayer");
+    u(this, "snapshotFullLayer");
+    u(this, "vNodes");
+    u(this, "master");
+    u(this, "opt");
+    u(this, "cameraOpt");
+    u(this, "scene");
+    u(this, "localWork");
+    u(this, "serviceWork");
+    u(this, "topWork");
+    u(this, "taskUpdateCameraId");
+    u(this, "taskUpdateCameraResolve");
+    u(this, "debounceUpdateCameraId");
+    u(this, "activeCameraSettledRender");
+    u(this, "activeCameraTaskContext");
+    u(this, "debounceUpdateCache", /* @__PURE__ */ new Set());
+    u(this, "mainThreadPostId");
+    u(this, "destroyed", !1);
+    u(this, "readbackScheduler");
+    u(this, "restoreLayerRenderCallbacks", []);
+    u(this, "viewOwner");
+    u(this, "viewGeneration");
+    u(this, "combinePostMsg", /* @__PURE__ */ new Set());
+    u(this, "methodBuilder");
+    u(this, "cacheImages", /* @__PURE__ */ new Map());
+    u(this, "imageResolveMap", /* @__PURE__ */ new Map());
+    this.viewId = e, this.opt = t, this.viewOwner = t.viewOwner, this.viewGeneration = t.viewGeneration, this.scene = this.createScene({
+      ...t.canvasOpt,
+      container: t.container
+    }), this.master = t.master;
+    const s = K.bufferSize.full, r = K.bufferSize.sub;
+    this.fullLayer = this.createLayer("fullLayer", this.scene, {
+      ...t.layerOpt,
+      bufferSize: this.viewId === Q ? s : r * 2
+    }), this.topLayer = this.createLayer("topLayer", this.scene, {
+      ...t.layerOpt,
+      bufferSize: (this.viewId === Q, r),
+      contextType: "2d"
+    }), this.localLayer = this.createLayer("localLayer", this.scene, {
+      ...t.layerOpt,
+      bufferSize: (this.viewId === Q, r),
+      contextType: "2d"
+    }), this.serviceLayer = this.createLayer("serviceLayer", this.scene, {
+      ...t.layerOpt,
+      bufferSize: (this.viewId === Q, r),
+      contextType: "2d"
+    }), t.mainThreadRenderMode === "readback" && this.enableCanvas2DReadback([
+      this.fullLayer.parent,
+      this.topLayer.parent,
+      this.localLayer.parent,
+      this.serviceLayer.parent
+    ]), this.vNodes = new We(e, this.scene);
+    const i = {
+      thread: this,
+      vNodes: this.vNodes
+    };
+    this.localWork = new Ae(i), this.serviceWork = new Fe(i), this.topWork = new Pe(i), this.vNodes.init(this.fullLayer), this.methodBuilder = new Ke([
+      N.CopyNode,
+      N.SetColorNode,
+      N.DeleteNode,
+      N.RotateNode,
+      N.ScaleNode,
+      N.TranslateNode,
+      N.ZIndexNode,
+      N.SetFontStyle,
+      N.SetPoint,
+      N.SetLock,
+      N.SetShapeOpt
+    ]).registerForMainThread(this);
+  }
+  getCachedImages(e) {
+    var t;
+    return (t = this.cacheImages.get(e)) == null ? void 0 : t.imageSource;
+  }
+  getCachedImagesByWorkId(e) {
+    for (const [t, s] of this.cacheImages.entries())
+      if (t === e && s.imageSource)
+        return s.imageSource;
+  }
+  deleteCachedImagesByWorkId(e) {
+    for (const [t, s] of this.cacheImages.entries())
+      s.workId === e && (this.closeImageSource(s.imageSource), this.cacheImages.delete(t));
+  }
+  clearCacheImages() {
+    this.cacheImages.forEach((e) => this.closeImageSource(e.imageSource)), this.cacheImages.clear();
+  }
+  closeImageSource(e) {
+    if (!(!("close" in e) || typeof e.close != "function"))
+      try {
+        e.close();
+      } catch {
+      }
+  }
+  clearImageResolveMap(e) {
+    this.imageResolveMap.forEach(({ timer: t, resolve: s, reject: r }, i) => {
+      t && clearTimeout(t), e !== void 0 ? r == null || r(e) : s == null || s(i);
+    }), this.imageResolveMap.clear();
+  }
+  post(e) {
+    this.destroyed || (this.combinePostMsg.add(e), this.runBatchPostData());
+  }
+  reportRendererBusinessError(e, t) {
+    const s = Y(e, t);
+    s.reported || (s.reported = !0, this.post({
+      sp: [
+        {
+          type: h.ReportError,
+          viewId: this.viewId,
+          viewGeneration: this.viewGeneration,
+          reportErrorCode: "RENDERER_RUNTIME_ERROR",
+          reportStage: s.stage,
+          reportError: s.message,
+          reportString: Re(s, t, {
+            viewId: this.viewId,
+            renderer: "mainThread"
+          })
+        }
+      ]
+    }));
+  }
+  updateDpr(e) {
+    this.scene.displayRatio = e;
+  }
+  async on(e) {
+    var t, s, r, i, o;
+    if (this.destroyed) {
+      try {
+        (t = e.imageBitmap) == null || t.close();
+      } catch {
+      }
+      return;
+    }
+    if (!await this.methodBuilder.consumeForMainThread(e)) {
+      const {
+        msgType: a,
+        toolsType: n,
+        opt: c,
+        dataType: d,
+        workId: l,
+        workState: p,
+        imageSrc: f,
+        imageBitmap: w,
+        imageElement: k,
+        workIds: I,
+        isLockSentEventCursor: W,
+        requestId: g
+      } = e, y = l == null ? void 0 : l.toString();
+      switch (a) {
+        case h.UpdateDpr:
+          G(e.dpr) && this.updateDpr(e.dpr);
+          break;
+        case h.AuthClear: {
+          const { clearUids: S, localUid: T } = e;
+          this.vNodes.setCanClearUids(S), this.vNodes.setLocalUid(T);
+          break;
+        }
+        case h.Destroy:
+          this.destroy();
+          break;
+        case h.Clear:
+          this.clearAll();
+          break;
+        case h.ServiceSyncCommit: {
+          if (this.destroyed) break;
+          const S = [
+            (s = this.fullLayer) == null ? void 0 : s.parent,
+            (r = this.topLayer) == null ? void 0 : r.parent,
+            (i = this.localLayer) == null ? void 0 : i.parent,
+            (o = this.serviceLayer) == null ? void 0 : o.parent
+          ].filter(Boolean);
+          try {
+            await be(
+              (async () => {
+                await Le(
+                  this.serviceWork,
+                  S
+                );
+              })(),
+              {
+                business: "service-sync-commit",
+                stage: "flush-and-prepare-render",
+                timeoutMs: 5e3
+              }
+            );
+          } catch (T) {
+            throw Y(T, {
+              business: "service-sync-commit",
+              stage: "flush-and-prepare-render"
+            });
+          }
+          if (this.destroyed) break;
+          this.post({
+            sp: [
+              {
+                type: h.ServiceSyncCommit,
+                viewId: this.viewId,
+                viewGeneration: this.viewGeneration,
+                scenePath: e.scenePath,
+                serviceSyncId: e.serviceSyncId,
+                serviceRevision: e.serviceRevision
+              }
+            ]
+          });
+          break;
+        }
+        case h.UpdateCamera:
+          try {
+            await Ee(
+              e.cameraTaskId,
+              async (S) => {
+                this.activeCameraTaskContext = S;
+                try {
+                  await this.updateCamera(e, S);
+                } finally {
+                  this.activeCameraTaskContext === S && (this.activeCameraTaskContext = void 0);
+                }
+              }
+            );
+          } catch (S) {
+            throw this.cameraOpt = void 0, this.cancelCameraSettledRender(), S;
+          }
+          break;
+        case h.UpdateTools:
+          if (n && c) {
+            const S = {
+              toolsType: n,
+              toolsOpt: c
+            };
+            this.topWork.canUseTopLayer(n) ? this.topWork.setToolsOpt(S) : this.localWork.setToolsOpt(S);
+          }
+          break;
+        case h.CreateWork:
+          if (y && c && n) {
+            if (this.topWork.canUseTopLayer(n)) {
+              this.topWork.getToolsOpt() || this.topWork.setToolsOpt({
+                toolsType: n,
+                toolsOpt: c
+              }), this.topWork.setWorkOptions(y, c);
+              break;
+            }
+            this.localWork.getToolsOpt() || this.localWork.setToolsOpt({
+              toolsType: n,
+              toolsOpt: c
+            }), this.localWork.setWorkOptions(y, c);
+          }
+          break;
+        case h.DrawWork:
+          p === b.Done && d === R.Local ? (await this.consumeDrawAll(d, e), n === m.LaserPen && W && this.post({
+            sp: [
+              {
+                type: h.None,
+                isLockSentEventCursor: W
+              }
+            ]
+          })) : await this.consumeDraw(d, e);
+          break;
+        case h.UpdateNode:
+        case h.FullWork:
+          if (n && this.topWork.canUseTopLayer(n)) {
+            await this.consumeDrawAll(d, e);
+            break;
+          }
+          await this.consumeFull(d, e);
+          break;
+        case h.RemoveNode:
+          await this.removeNode(e);
+          return;
+        case h.Select:
+          d === R.Local || l === D ? await this.localWork.updateFullSelectWork(e) : d === R.Service && this.serviceWork.runSelectWork(e);
+          break;
+        case h.CursorBlur:
+          this.localWork.cursorBlur();
+          return;
+        case h.CursorHover:
+          this.localWork.cursorHover(e);
+          break;
+        case h.GetTextActive:
+          d === R.Local && this.localWork.checkTextActive(e);
+          break;
+        case h.GetImageBitMap:
+          if (f && (w || k) && l) {
+            const S = this.imageResolveMap.get(f);
+            if (!S || S.requestId !== g) {
+              this.closeImageSource(w || k);
+              break;
+            }
+            const T = l.toString();
+            this.deleteCachedImagesByWorkId(T), this.cacheImages.set(f, {
+              imageSource: w || k,
+              workId: T
+            });
+            const { resolve: C, timer: L } = S;
+            L && clearTimeout(L), C && C(f);
+          }
+          break;
+        case h.GetVNodeInfo:
+          if (l && I) {
+            const S = I.map((T) => this.vNodes.get(T));
+            this.post({
+              sp: [
+                {
+                  type: h.GetVNodeInfo,
+                  dataType: R.Local,
+                  workId: l,
+                  vInfo: S
+                }
+              ]
+            });
+          }
+          break;
+      }
+    }
+  }
+  getIconSize(e, t, s) {
+    const r = e * s, i = t * s;
+    return r <= 50 || i <= 50 ? [50, 50] : r <= 100 || i <= 100 ? [100, 100] : r <= 200 || i <= 200 ? [200, 200] : r <= 400 || i <= 400 ? [400, 400] : r <= 800 || i <= 800 ? [800, 800] : [1600, 1600];
+  }
+  async loadImageBitMap(e) {
+    const { toolsType: t, opt: s, workId: r, requestId: i } = e;
+    if (t === m.Image && s && r) {
+      const o = r.toString(), { src: a, type: n, width: c, height: d, strokeColor: l } = s;
+      if (!a || !n || !c || !d)
+        return;
+      let p = a;
+      if (n === pe.Iconify) {
+        const [y, S] = this.getIconSize(c, d, this.opt.displayer.dpr);
+        p = ue(a, y, S, l);
+      }
+      if (this.cacheImages.has(p)) {
+        const y = this.getCachedImages(p);
+        if (y)
+          return y;
+      }
+      const w = this.imageResolveMap.get(p);
+      if (w)
+        return await w.promise, this.getCachedImages(p);
+      let k, I;
+      const W = new Promise((y, S) => {
+        k = y, I = S;
+      }), g = {
+        resolve: k,
+        reject: I,
+        timer: void 0,
+        requestId: i,
+        promise: W
+      };
+      return g.timer = setTimeout(() => {
+        this.imageResolveMap.get(p) === g && k(p);
+      }, 5e3), this.imageResolveMap.set(p, g), this.opt.post({
+        sp: [
+          {
+            imageSrc: p,
+            workId: o,
+            viewId: this.viewId,
+            isgl: !!this.fullLayer.parent.gl,
+            isSubWorker: !1,
+            requestId: i,
+            type: h.GetImageBitMap
+          }
+        ]
+      }), await W, this.imageResolveMap.get(p) === g && this.imageResolveMap.delete(p), this.getCachedImages(p);
+    }
+  }
+  async removeNode(e) {
+    const { dataType: t, workId: s, removeIds: r } = e, i = r || [];
+    if (s && i.push(s.toString()), i.length)
+      for (const o of i) {
+        if (o === D) {
+          await this.localWork.removeSelector(e);
+          continue;
+        }
+        t === R.Local ? this.localWork.removeWork(e) : t === R.Service && this.serviceWork.removeWork(e), await this.localWork.colloctEffectSelectWork(e);
+      }
+  }
+  async consumeFull(e, t) {
+    const s = await this.localWork.colloctEffectSelectWork(t);
+    s && e === R.Local && await this.localWork.consumeFull(s), s && e === R.Service && this.serviceWork.consumeFull(s);
+  }
+  setCameraOpt(e) {
+    this.cameraOpt = e;
+    const { scale: t, centerX: s, centerY: r, width: i, height: o } = e;
+    (i !== this.scene.width || o !== this.scene.height) && this.updateScene({ width: i, height: o }), this.fullLayer.setAttribute("scale", [t, t]), this.fullLayer.setAttribute("translate", [-s, -r]), this.topLayer.setAttribute("scale", [t, t]), this.topLayer.setAttribute("translate", [-s, -r]), this.localLayer.setAttribute("scale", [t, t]), this.localLayer.setAttribute("translate", [-s, -r]), this.serviceLayer.setAttribute("scale", [t, t]), this.serviceLayer.setAttribute("translate", [-s, -r]);
+  }
+  runBatchPostData() {
+    this.destroyed || this.mainThreadPostId || (this.mainThreadPostId = requestAnimationFrame(
+      this.combinePost.bind(this)
+    ));
+  }
+  combinePostData() {
+    var i;
+    this.mainThreadPostId = void 0;
+    const e = [];
+    let t, s, r;
+    for (const o of this.combinePostMsg.values()) {
+      if ((i = o.sp) != null && i.length)
+        for (const a of o.sp) {
+          const n = {
+            ...a,
+            viewId: a.viewId || this.viewId,
+            viewGeneration: a.viewGeneration ?? this.viewGeneration
+          };
+          let c = !1;
+          for (const d of e)
+            if (le(n, d)) {
+              c = !0;
+              break;
+            }
+          c || e.push(n);
+        }
+      G(o.fullWorkerDrawCount) && (t = o.fullWorkerDrawCount), G(o.consumeCount) && (s = o.consumeCount, r = o.consumeWorkId);
+    }
+    return this.combinePostMsg.clear(), {
+      sp: e,
+      fullWorkerDrawCount: t,
+      consumeCount: s,
+      consumeWorkId: r,
+      viewId: this.viewId,
+      viewGeneration: this.viewGeneration,
+      viewOwner: this.viewOwner
+    };
+  }
+  combinePost() {
+    var s, r;
+    if (this.destroyed) {
+      this.mainThreadPostId = void 0, this.combinePostMsg.clear();
+      return;
+    }
+    const e = this.combinePostData(), t = (s = e.sp) == null ? void 0 : s.filter(
+      (i) => i.type !== h.None || i.isLockSentEventCursor || i.needUndoTicker || i.collectUndoTicker || i.eraseTxnPhase
+    );
+    t != null && t.length ? e.sp = t.map((i) => ({
+      ...i,
+      viewId: i.viewId || this.viewId,
+      viewGeneration: i.viewGeneration ?? this.viewGeneration
+    })) : delete e.sp, e.consumeCount === void 0 && (delete e.consumeCount, delete e.consumeWorkId), e.fullWorkerDrawCount === void 0 && delete e.fullWorkerDrawCount, !this.destroyed && (e != null && e.consumeCount || e != null && e.fullWorkerDrawCount || (r = e.sp) != null && r.length) && this.opt.post(e);
+  }
+  clearAll() {
+    this.cancelCameraSettledRender(), this.debounceUpdateCache.clear(), this.fullLayer.children.length && (this.fullLayer.parent.children.forEach((e) => {
+      e.name !== "viewport" && e.remove();
+    }), $(this.fullLayer, this.fullLayer.parent)), this.clearCacheImages(), this.clearImageResolveMap(), this.localWork.clearAll(), this.topWork.clearAll(), this.serviceWork.clearAll(), this.vNodes.clear(), this.post({
+      sp: [
+        {
+          type: h.Clear
+        }
+      ]
+    });
+  }
+  async consumeDrawAll(e, t) {
+    const { toolsType: s, workId: r } = t;
+    if (r) {
+      const i = r.toString();
+      if (s && this.topWork.canUseTopLayer(s)) {
+        e === R.Local && (this.topWork.getLocalWorkShape(
+          r.toString()
+        ) || this.topWork.createLocalWork(t)), await this.topWork.consumeDrawAll(t);
+        return;
+      }
+      e === R.Local && (this.localWork.getWorkShape(i) || this.localWork.createLocalWork(t), await this.localWork.consumeDrawAll(t, this.serviceWork));
+    }
+  }
+  async consumeDraw(e, t) {
+    const { opt: s, workId: r, toolsType: i } = t;
+    if (r && i && s) {
+      const o = r.toString();
+      if (this.topWork.canUseTopLayer(i)) {
+        e === R.Local && (this.topWork.getLocalWorkShape(o) || this.topWork.createLocalWork(t)), this.topWork.consumeDraw(t);
+        return;
+      }
+      e === R.Local ? (this.localWork.getWorkShape(o) || this.localWork.createLocalWork(t), await this.localWork.consumeDraw(t, this.serviceWork)) : e === R.Service && this.serviceWork.consumeDraw(t);
+      return;
+    }
+  }
+  async updateCamera(e, t) {
+    var d, l;
+    const { cameraOpt: s, scenePath: r, cameraTaskId: i } = e;
+    let o = !1;
+    const a = this.cameraOpt, n = !!(s && le(a, s));
+    let c = !1;
+    if (s && n) {
+      const p = !!this.activeCameraSettledRender;
+      if (this.retargetCameraSettledRender(i)) return;
+      if (!p) {
+        G(i) && this.opt.post({
+          viewId: this.viewId,
+          viewGeneration: this.viewGeneration,
+          cameraSettledTaskId: i
+        });
+        return;
+      }
+      c = !0;
+    }
+    if (s && (!n || c)) {
+      this.cancelCameraSettledRender();
+      const p = !a || a.scale !== s.scale || a.centerX !== s.centerX || a.centerY !== s.centerY || a.width !== s.width || a.height !== s.height;
+      if (this.taskUpdateCameraId && (clearTimeout(this.taskUpdateCameraId), this.taskUpdateCameraId = void 0, (d = this.taskUpdateCameraResolve) == null || d.call(this, !1), this.taskUpdateCameraResolve = void 0), r) {
+        let y;
+        do {
+          y = [];
+          for (const [T, C] of this.localWork.getWorkShapes().entries())
+            switch (C.toolsType) {
+              case m.Text:
+              case m.BitMapEraser:
+              case m.PencilEraser:
+              case m.Eraser:
+              case m.Selector:
+              case m.LaserPen:
+                break;
+              default:
+                T !== H && T !== D && y.push(`${T}:${C.toolsType}`);
+                break;
+            }
+          if (t && (t.stage = "blocking-works", t.blockingWorks = y), !y.length) break;
+          if (!await new Promise((T) => {
+            this.taskUpdateCameraResolve = T, this.taskUpdateCameraId = setTimeout(() => {
+              this.taskUpdateCameraId = void 0, this.taskUpdateCameraResolve = void 0, T(!0);
+            }, oe);
+          }) || t != null && t.aborted) return;
+        } while (y.length);
+        t && (t.stage = "update-camera", t.blockingWorks = void 0);
+      }
+      if (t != null && t.aborted) return;
+      const f = /* @__PURE__ */ new Map();
+      for (const [y, S] of this.vNodes.getNodesByType(m.Text).entries()) {
+        const T = S.rect;
+        f.set(y, J(T));
+      }
+      for (const [y, S] of this.vNodes.gethasEraserNodes().entries())
+        f.set(y, J(S.rect));
+      const w = new Set(f.keys());
+      let k = !1;
+      if (this.localWork.hasSelector()) {
+        const y = (l = this.localWork.getSelector()) == null ? void 0 : l.selectIds;
+        if (y) {
+          k = !0;
+          for (const S of y)
+            w.add(S);
+        }
+      }
+      let I = !1;
+      if (this.serviceWork.selectorWorkShapes.size)
+        for (const y of this.serviceWork.selectorWorkShapes.values()) {
+          const S = y.selectIds;
+          if (S) {
+            I = !0;
+            for (const T of S)
+              w.add(T);
+          }
+        }
+      if (this.setCameraOpt(s), this.vNodes.curNodeMap.size) {
+        this.vNodes.clearTarget(), this.vNodes.updateHighLevelNodesRect(w);
+        for (const [T, C] of f.entries()) {
+          const L = this.vNodes.get(T);
+          if (L) {
+            const A = C, E = L.rect, v = this.getSceneRect(), O = ae(A, v), B = ae(E, v);
+            let P = c;
+            (O !== B || A.w !== E.w || A.h !== E.h || B === Ce.intersect) && (P = !0);
+            const { toolsType: F, opt: U } = L, X = U.eraserlines && U.eraserlines.length > 0 || !!U.eraserFaces;
+            (P || p && X) && (F === m.Text || X) && this.debounceUpdateCache.add(T);
+          }
+        }
+        if (k && this.localWork.reRenderSelector(), I)
+          for (const [
+            T,
+            C
+          ] of this.serviceWork.selectorWorkShapes.entries())
+            this.serviceWork.runSelectWork({
+              workId: T,
+              selectIds: C.selectIds,
+              msgType: h.Select,
+              dataType: R.Service,
+              viewId: this.viewId
+            });
+        o = !0;
+        const y = { cancelled: !1, cameraTaskId: i, context: t };
+        this.activeCameraSettledRender = y;
+        const S = () => !this.destroyed && !y.cancelled && this.activeCameraSettledRender === y && !(t != null && t.aborted);
+        this.debounceUpdateCameraId = setTimeout(async () => {
+          var T;
+          this.debounceUpdateCameraId = void 0;
+          try {
+            if (!S()) return;
+            const C = [];
+            for (const E of this.debounceUpdateCache.values()) {
+              const v = (T = this.fullLayer) == null ? void 0 : T.getElementsByName(E)[0], O = this.vNodes.get(E);
+              if (O) {
+                const { toolsType: B, opt: P } = O;
+                if (v || B !== m.Text) {
+                  const F = this.localWork.setFullWork({
+                    toolsType: B,
+                    opt: P,
+                    workId: E
+                  });
+                  if (F) {
+                    if (B === m.Text)
+                      C.push(
+                        F.consumeServiceAsync({
+                          isFullWork: !0,
+                          replaceId: E,
+                          boxRect: this.getSceneRect(),
+                          isActive: S
+                        })
+                      );
+                    else if (P.eraserlines && P.eraserlines.length > 0 || P.eraserFaces) {
+                      const U = F.consumeService({
+                        op: O.op,
+                        isFullWork: !0,
+                        replaceId: E,
+                        workState: b.Done
+                      });
+                      this.localWork.clearWorkShapeNodeCache(E), C.push(Promise.resolve(U));
+                    }
+                  }
+                }
+              }
+              this.debounceUpdateCache.delete(E);
+            }
+            if (await Promise.all(C), !S()) return;
+            this.vNodes.updateLowLevelNodesRect(), this.vNodes.clearHighLevelIds();
+            const L = [
+              this.fullLayer.parent.prepareRender,
+              this.topLayer.parent.prepareRender,
+              this.localLayer.parent.prepareRender,
+              this.serviceLayer.parent.prepareRender
+            ];
+            if (y.renderLayers = [
+              this.fullLayer.parent,
+              this.topLayer.parent,
+              this.localLayer.parent,
+              this.serviceLayer.parent
+            ], await Promise.all(L), y.renderLayers = void 0, !S()) return;
+            const A = y.cameraTaskId;
+            G(A) && this.opt.post({
+              viewId: this.viewId,
+              viewGeneration: this.viewGeneration,
+              cameraSettledTaskId: A
+            });
+          } catch (C) {
+            if (!S()) return;
+            const L = {
+              code: "RENDERER_BUSINESS_ERROR",
+              business: "updateCamera",
+              message: C instanceof Error ? C.message : String(C),
+              stage: "camera-settled-render",
+              workerType: "mainThread"
+            }, A = y.cameraTaskId;
+            if (G(A))
+              try {
+                this.opt.post({
+                  viewId: this.viewId,
+                  viewGeneration: this.viewGeneration,
+                  cameraTaskId: A,
+                  cameraTaskStatus: "failed",
+                  cameraTaskError: L
+                });
+              } catch (E) {
+                console.error(
+                  `[cameraSettledRender] failed ACK post failed viewId=${this.viewId} taskId=${A}`,
+                  E
+                );
+              }
+          } finally {
+            y.renderLayers = void 0, this.activeCameraSettledRender === y && (this.activeCameraSettledRender = void 0);
+          }
+        }, oe);
+      }
+      const W = [
+        this.fullLayer.parent,
+        this.topLayer.parent,
+        this.localLayer.parent,
+        this.serviceLayer.parent
+      ], g = Promise.all(
+        W.map((y) => y.prepareRender)
+      );
+      if (t && !await Ne(
+        t,
+        g,
+        "prepare-render"
+      )) {
+        W.filter(
+          (S) => S.cancelPendingRender()
+        ).forEach((S) => S.render()), g.catch(() => {
+        });
+        return;
+      }
+      if (t || await g, t != null && t.aborted) return;
+      !o && G(i) && this.opt.post({
+        viewId: this.viewId,
+        viewGeneration: this.viewGeneration,
+        cameraSettledTaskId: i
+      });
+    }
+  }
+  getSceneRect() {
+    const { width: e, height: t } = this.scene;
+    return {
+      x: 0,
+      y: 0,
+      w: Math.floor(e),
+      h: Math.floor(t)
+    };
+  }
+  createScene(e) {
+    return new fe({
+      displayRatio: this.opt.displayer.dpr,
+      depth: !1,
+      desynchronized: !0,
+      ...e,
+      autoRender: !0,
+      id: this.viewId,
+      contextType: "2d"
+    });
+  }
+  createLayer(e, t, s) {
+    const { width: r, height: i } = s, o = `canvas-${e}`, a = t.layer(o, { ...s, offscreen: !1 }), n = new me({
+      anchor: [0.5, 0.5],
+      pos: [r * 0.5, i * 0.5],
+      size: [r, i],
+      name: "viewport",
+      id: e
+    });
+    return a.append(n), n;
+  }
+  enableCanvas2DReadback(e) {
+    this.readbackScheduler = new Ze({
+      onReadbackError: (t) => this.opt.master.Logger.warn(
+        `[Appliance]: [main-thread-readback] stage=failed viewId=${this.viewId} error=${t instanceof Error ? t.message : String(t)}`
+      )
+    });
+    for (const t of e) {
+      const s = t.render, r = (...i) => {
+        var n;
+        const o = s.apply(t, i), a = t.canvas;
+        return a instanceof HTMLCanvasElement && ((n = this.readbackScheduler) == null || n.markRendered(a)), o;
+      };
+      t.render = r, this.restoreLayerRenderCallbacks.push(() => {
+        t.render === r && (t.render = s);
+      });
+    }
+  }
+  disableCanvas2DReadback() {
+    var e;
+    (e = this.readbackScheduler) == null || e.destroy(), this.readbackScheduler = void 0;
+    for (const t of this.restoreLayerRenderCallbacks.splice(0)) t();
+  }
+  updateScene(e) {
+    this.scene.attr({ ...e });
+    const { width: t, height: s } = e;
+    this.scene.width = t, this.scene.height = s, this.updateLayer({ width: t, height: s });
+  }
+  updateLayer(e) {
+    const { width: t, height: s } = e;
+    this.fullLayer.parent.setAttribute("width", t), this.fullLayer.parent.setAttribute("height", s), this.fullLayer.setAttribute("size", [t, s]), this.fullLayer.setAttribute("pos", [t * 0.5, s * 0.5]), this.topLayer.parent.setAttribute("width", t), this.topLayer.parent.setAttribute("height", s), this.topLayer.setAttribute("size", [t, s]), this.topLayer.setAttribute("pos", [t * 0.5, s * 0.5]), this.localLayer.parent.setAttribute("width", t), this.localLayer.parent.setAttribute("height", s), this.localLayer.setAttribute("size", [t, s]), this.localLayer.setAttribute("pos", [t * 0.5, s * 0.5]), this.serviceLayer.parent.setAttribute("width", t), this.serviceLayer.parent.setAttribute("height", s), this.serviceLayer.setAttribute("size", [t, s]), this.serviceLayer.setAttribute("pos", [t * 0.5, s * 0.5]);
+  }
+  cancelCameraSettledRender() {
+    var t;
+    this.debounceUpdateCameraId !== void 0 && (clearTimeout(this.debounceUpdateCameraId), this.debounceUpdateCameraId = void 0);
+    const e = this.activeCameraSettledRender;
+    e && (e.cancelled = !0, (t = e.renderLayers) == null || t.forEach((s) => s.cancelPendingRender()), this.activeCameraSettledRender = void 0);
+  }
+  retargetCameraSettledRender(e) {
+    var s;
+    if (!G(e)) return !1;
+    const t = this.activeCameraSettledRender;
+    return !t || t.cancelled || (s = t.context) != null && s.aborted ? !1 : (t.cameraTaskId = e, !0);
+  }
+  cancelCameraBlockingWait() {
+    this.taskUpdateCameraId !== void 0 && (clearTimeout(this.taskUpdateCameraId), this.taskUpdateCameraId = void 0);
+    const e = this.taskUpdateCameraResolve;
+    this.taskUpdateCameraResolve = void 0, e == null || e(!1);
+  }
+  destroy() {
+    var e, t;
+    this.destroyed || (this.destroyed = !0, this.disableCanvas2DReadback(), (t = (e = this.activeCameraTaskContext) == null ? void 0 : e.abort) == null || t.call(e), this.activeCameraTaskContext = void 0, this.mainThreadPostId !== void 0 && (cancelAnimationFrame(this.mainThreadPostId), this.mainThreadPostId = void 0), this.combinePostMsg.clear(), this.cancelCameraBlockingWait(), this.cancelCameraSettledRender(), this.debounceUpdateCache.clear(), this.clearCacheImages(), this.clearImageResolveMap(
+      new Error(`main-thread view destroyed: ${this.viewId}`)
+    ), this.vNodes.clear(), Xe({
+      subThreads: [this.localWork, this.serviceWork, this.topWork],
+      layers: [
+        this.fullLayer,
+        this.topLayer,
+        this.localLayer,
+        this.serviceLayer
+      ],
+      scene: this.scene,
+      removeLayerTexture: (s, r) => z(s, r)
+    }));
+  }
+}
+class Je {
+  constructor(e, t) {
+    u(this, "viewId");
+    u(this, "fullLayer");
+    u(this, "master");
+    u(this, "opt");
+    u(this, "viewOwner");
+    u(this, "viewGeneration");
+    u(this, "scene");
+    u(this, "mainThreadPostId");
+    u(this, "combinePostMsg", /* @__PURE__ */ new Set());
+    u(this, "destroyed", !1);
+    u(this, "workShapes", /* @__PURE__ */ new Map());
+    u(this, "cacheImages", /* @__PURE__ */ new Map());
+    u(this, "imageResolveMap", /* @__PURE__ */ new Map());
+    u(this, "activeRequest");
+    this.viewId = e, this.opt = t, this.viewOwner = t.viewOwner, this.viewGeneration = t.viewGeneration, this.scene = this.createScene({
+      ...t.canvasOpt,
+      container: t.container
+    }), this.master = t.master, this.fullLayer = this.createLayer("fullLayer", this.scene, {
+      ...t.layerOpt,
+      bufferSize: this.viewId === Q ? 6e3 : 3e3,
+      contextType: "2d"
+    });
+  }
+  getCachedImages(e) {
+    var t;
+    return (t = this.cacheImages.get(e)) == null ? void 0 : t.imageSource;
+  }
+  getCachedImagesByWorkId(e) {
+    for (const [t, s] of this.cacheImages.entries())
+      if (t === e && s.imageSource)
+        return s.imageSource;
+  }
+  deleteCachedImagesByWorkId(e) {
+    for (const [t, s] of this.cacheImages.entries())
+      s.workId === e && (this.closeImageSource(s.imageSource), this.cacheImages.delete(t));
+  }
+  clearCacheImages() {
+    this.cacheImages.forEach((e) => this.closeImageSource(e.imageSource)), this.cacheImages.clear();
+  }
+  closeImageSource(e) {
+    if (e && !(!("close" in e) || typeof e.close != "function"))
+      try {
+        e.close();
+      } catch {
+      }
+  }
+  releaseMessageImageBitmap(e) {
+    this.closeImageSource(e == null ? void 0 : e.imageBitmap);
+  }
+  releaseBatchImageBitmaps(e) {
+    var t, s;
+    (t = e == null ? void 0 : e.render) == null || t.forEach(
+      (r) => this.closeImageSource(r.imageBitmap)
+    ), (s = e == null ? void 0 : e.sp) == null || s.forEach((r) => this.releaseMessageImageBitmap(r));
+  }
+  clearImageResolveMap() {
+    this.imageResolveMap.forEach(({ timer: e, resolve: t }, s) => {
+      e && clearTimeout(e), t == null || t(s);
+    }), this.imageResolveMap.clear();
+  }
+  post(e) {
+    if (this.destroyed) {
+      this.releaseBatchImageBitmaps(e);
+      return;
+    }
+    this.combinePostMsg.add(e), this.runBatchPostData();
+  }
+  reportRequestFailure(e, t, s, r, i) {
+    const o = r instanceof Error ? r.message : String(r);
+    try {
+      this.opt.post({
+        viewId: this.viewId,
+        viewGeneration: this.viewGeneration,
+        viewOwner: this.viewOwner,
+        sp: [
+          {
+            type: h.ReportError,
+            viewId: this.viewId,
+            scenePath: s,
+            requestId: t,
+            reportBusiness: e,
+            reportStage: i,
+            reportError: o,
+            reportString: `[SnapshotThreadImpl] ${e} failed; stage=${i}; requestId=${t || "unknown"}; error=${o}`
+          }
+        ]
+      });
+    } catch (a) {
+      console.error(
+        `[SnapshotThreadImpl] ${e} failure report failed`,
+        a
+      );
+    }
+  }
+  async on(e) {
+    if (this.destroyed) {
+      this.closeImageSource(e.imageBitmap);
+      return;
+    }
+    const { msgType: t, imageSrc: s, imageBitmap: r, imageElement: i, workId: o, requestId: a } = e;
+    switch (t) {
+      case h.Snapshot: {
+        this.activeRequest = {
+          business: "snapshot",
+          scenePath: e.scenePath,
+          requestId: e.requestId
+        };
+        try {
+          await this.getSnapshot(e), this.flushPendingPost();
+        } catch (n) {
+          this.destroyed || this.reportRequestFailure(
+            "snapshot",
+            e.requestId,
+            e.scenePath,
+            n,
+            "render"
+          );
+        } finally {
+          this.activeRequest = void 0, this.destroy();
+        }
+        return;
+      }
+      case h.BoundingBox: {
+        this.activeRequest = {
+          business: "bounding-box",
+          scenePath: e.scenePath,
+          requestId: e.requestId
+        };
+        try {
+          await this.getBoundingRect(e), this.flushPendingPost();
+        } catch (n) {
+          this.destroyed || this.reportRequestFailure(
+            "bounding-box",
+            e.requestId,
+            e.scenePath,
+            n,
+            "compute"
+          );
+        } finally {
+          this.activeRequest = void 0, this.destroy();
+        }
+        return;
+      }
+      case h.GetImageBitMap: {
+        if (s && (r || i) && o) {
+          const n = o.toString(), c = this.imageResolveMap.get(s);
+          if (!c || c.requestId !== a) {
+            this.closeImageSource(r || i);
+            break;
+          }
+          if (this.deleteCachedImagesByWorkId(n), this.cacheImages.set(s, {
+            imageSource: r || i,
+            workId: n
+          }), c) {
+            const { resolve: d, timer: l } = c;
+            l && clearTimeout(l), d && d(s);
+          }
+        }
+        break;
+      }
+    }
+  }
+  getIconSize(e, t, s) {
+    const r = e * s, i = t * s;
+    return r <= 50 || i <= 50 ? [50, 50] : r <= 100 || i <= 100 ? [100, 100] : r <= 200 || i <= 200 ? [200, 200] : r <= 400 || i <= 400 ? [400, 400] : r <= 800 || i <= 800 ? [800, 800] : [1600, 1600];
+  }
+  async loadImageBitMap(e) {
+    const { toolsType: t, opt: s, workId: r, requestId: i } = e;
+    if (t === m.Image && s && r) {
+      const o = r.toString(), { src: a, type: n, width: c, height: d, strokeColor: l } = s;
+      if (!a || !n || !c || !d)
+        return;
+      let p = a;
+      if (n === pe.Iconify) {
+        const [g, y] = this.getIconSize(c, d, this.opt.displayer.dpr);
+        p = ue(a, g, y, l);
+      }
+      if (this.cacheImages.has(p)) {
+        const g = this.getCachedImages(p);
+        if (g)
+          return g;
+      }
+      const w = this.imageResolveMap.get(p);
+      if (w)
+        return await w.promise, this.getCachedImages(p);
+      let k;
+      const I = new Promise((g) => {
+        k = g;
+      }), W = {
+        resolve: k,
+        timer: void 0,
+        requestId: i,
+        promise: I
+      };
+      return W.timer = setTimeout(() => {
+        this.imageResolveMap.get(p) === W && k(p);
+      }, 5e3), this.imageResolveMap.set(p, W), this.opt.post({
+        viewId: this.viewId,
+        viewGeneration: this.viewGeneration,
+        viewOwner: this.viewOwner,
+        sp: [
+          {
+            imageSrc: p,
+            workId: o,
+            viewId: this.viewId,
+            isgl: !!this.fullLayer.parent.gl,
+            isSubWorker: !0,
+            type: h.GetImageBitMap,
+            requestId: i
+          }
+        ]
+      }), await I, this.imageResolveMap.get(p) === W && this.imageResolveMap.delete(p), this.getCachedImages(p);
+    }
+  }
+  createWorkShapeNode(e) {
+    return Z({
+      ...e,
+      fullLayer: this.fullLayer,
+      drawLayer: void 0
+    });
+  }
+  setFullWork(e) {
+    const { workId: t, opt: s, toolsType: r } = e;
+    if (t && s && r) {
+      const i = t.toString();
+      let o;
+      return t && this.workShapes.has(i) ? (o = this.workShapes.get(i), o == null || o.setWorkOptions(s)) : o = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: r,
+        workId: i
+      }), o ? (this.workShapes.set(i, o), o) : void 0;
+    }
+  }
+  async runFullWork(e) {
+    var r;
+    const t = this.setFullWork(e), s = e.ops && V(e.ops);
+    if (t) {
+      let i, o;
+      const a = (r = t.getWorkId()) == null ? void 0 : r.toString();
+      return t.toolsType === m.BackgroundSVG ? i = t.consumeService({
+        isFullWork: !0,
+        replaceId: a
+      }) : t.toolsType === m.Image ? i = await t.consumeServiceAsync({
+        isFullWork: !0,
+        worker: this,
+        requestId: e.requestId
+      }) : t.toolsType === m.Text ? i = await t.consumeServiceAsync({
+        isFullWork: !0,
+        replaceId: a,
+        isDrawLabel: !0
+      }) : (i = t.consumeService({
+        op: s,
+        isFullWork: !0,
+        replaceId: a
+      }), o = (e == null ? void 0 : e.updateNodeOpt) && t.updataOptService(e.updateNodeOpt)), ne(i, o);
+    }
+  }
+  async getSnapshot(e) {
+    const { scenePath: t, scenes: s, cameraOpt: r, w: i, h: o, requestId: a } = e;
+    if (!(t && s && r))
+      throw new Error("snapshot input is incomplete");
+    this.setCameraOpt(r);
+    for (const [c, d] of Object.entries(s))
+      if (d != null && d.type)
+        switch (d == null ? void 0 : d.type) {
+          case h.UpdateNode:
+          case h.FullWork: {
+            const { opt: l } = d, p = {
+              ...d,
+              opt: l,
+              workId: c,
+              msgType: h.FullWork,
+              dataType: R.Service,
+              viewId: this.viewId,
+              requestId: a
+            };
+            await this.runFullWork(p);
+            break;
+          }
+        }
+    let n;
+    i && o && (n = {
+      resizeWidth: i,
+      resizeHeight: o
+    }), await this.getSnapshotRender({ scenePath: t, options: n, requestId: a });
+  }
+  getSceneRect() {
+    const { width: e, height: t } = this.scene;
+    return {
+      x: 0,
+      y: 0,
+      w: Math.floor(e),
+      h: Math.floor(t)
+    };
+  }
+  getRectImageBitmap(e, t) {
+    const s = Math.floor(e.x * this.opt.displayer.dpr), r = Math.floor(e.y * this.opt.displayer.dpr), i = e.w > 0 && Math.floor(e.w * this.opt.displayer.dpr || 1) || 1, o = e.h > 0 && Math.floor(e.h * this.opt.displayer.dpr || 1) || 1;
+    return createImageBitmap(
+      this.fullLayer.parent.canvas,
+      s,
+      r,
+      i,
+      o,
+      t
+    );
+  }
+  async getSnapshotRender(e) {
+    var o;
+    const { scenePath: t, options: s, requestId: r } = e;
+    ((o = this.fullLayer) == null ? void 0 : o.parent).render();
+    const i = await this.getRectImageBitmap(
+      this.getSceneRect(),
+      s
+    );
+    if (i) {
+      if (this.destroyed) {
+        this.closeImageSource(i);
+        return;
+      }
+      this.post({
+        sp: [
+          {
+            type: h.Snapshot,
+            scenePath: t,
+            imageBitmap: i,
+            viewId: this.viewId,
+            index: 0,
+            requestId: r
+          }
+        ]
+      }), this.fullLayer && !this.destroyed && $(this.fullLayer, this.fullLayer.parent);
+    }
+  }
+  async getBoundingRect(e) {
+    const { scenePath: t, scenes: s, cameraOpt: r, requestId: i } = e;
+    if (!(t && s && r))
+      throw new Error("bounding-box input is incomplete");
+    this.setCameraOpt(r);
+    let o;
+    for (const [a, n] of Object.entries(s))
+      if (n != null && n.type)
+        switch (n == null ? void 0 : n.type) {
+          case h.UpdateNode:
+          case h.FullWork: {
+            const c = await this.runFullWork({
+              ...n,
+              workId: a,
+              msgType: h.FullWork,
+              dataType: R.Service,
+              viewId: this.viewId,
+              requestId: i
+            });
+            o = ne(o, c);
+            break;
+          }
+        }
+    this.post({
+      sp: [
+        {
+          type: h.BoundingBox,
+          scenePath: t,
+          rect: o || { x: 0, y: 0, w: 0, h: 0 },
+          viewId: this.viewId,
+          requestId: i
+        }
+      ]
+    });
+  }
+  setCameraOpt(e) {
+    const { scale: t, centerX: s, centerY: r, width: i, height: o } = e;
+    this.updateScene({ width: i, height: o }), this.fullLayer.setAttribute("scale", [t, t]), this.fullLayer.setAttribute("translate", [-s, -r]);
+  }
+  runBatchPostData() {
+    this.destroyed || this.mainThreadPostId || (this.mainThreadPostId = requestAnimationFrame(
+      this.combinePost.bind(this)
+    ));
+  }
+  flushPendingPost() {
+    !this.combinePostMsg.size || this.destroyed || (this.mainThreadPostId !== void 0 && (cancelAnimationFrame(this.mainThreadPostId), this.mainThreadPostId = void 0), this.combinePost());
+  }
+  combinePostData() {
+    var t;
+    this.mainThreadPostId = void 0;
+    const e = [];
+    for (const s of this.combinePostMsg.values())
+      if ((t = s.sp) != null && t.length)
+        for (const r of s.sp) {
+          let i = !1;
+          for (const o of e)
+            if (Oe(r, o)) {
+              i = !0;
+              break;
+            }
+          i ? this.releaseMessageImageBitmap(r) : e.push(r);
+        }
+    return this.combinePostMsg.clear(), {
+      sp: e
+    };
+  }
+  combinePost() {
+    var s, r;
+    if (this.destroyed) {
+      this.mainThreadPostId = void 0, this.releaseBatchImageBitmaps({
+        sp: [...this.combinePostMsg].flatMap((i) => i.sp || [])
+      }), this.combinePostMsg.clear();
+      return;
+    }
+    const e = this.combinePostData(), t = (s = e.sp) == null ? void 0 : s.filter(
+      (i) => i.type !== h.None || i.isLockSentEventCursor || i.needUndoTicker
+    );
+    if (e.sp && t) {
+      const i = new Set(t);
+      e.sp.filter((o) => !i.has(o)).forEach((o) => this.releaseMessageImageBitmap(o));
+    }
+    if (t != null && t.length ? e.sp = t.map((i) => i.viewId ? i : { ...i, viewId: this.viewId }) : delete e.sp, !this.destroyed && ((r = e.sp) != null && r.length))
+      try {
+        this.opt.post({
+          ...e,
+          viewId: this.viewId,
+          viewGeneration: this.viewGeneration,
+          viewOwner: this.viewOwner
+        });
+      } catch (i) {
+        throw this.releaseBatchImageBitmaps(e), i;
+      }
+    else
+      this.releaseBatchImageBitmaps(e);
+  }
+  createScene(e) {
+    return new fe({
+      displayRatio: this.opt.displayer.dpr,
+      depth: !1,
+      desynchronized: !0,
+      ...e,
+      autoRender: !1,
+      contextType: "2d"
+    });
+  }
+  createLayer(e, t, s) {
+    const { width: r, height: i } = s, o = `canvas-${e}`, a = t.layer(o, s), n = new me({
+      anchor: [0.5, 0.5],
+      pos: [r * 0.5, i * 0.5],
+      size: [r, i],
+      name: "viewport",
+      id: e
+    });
+    return a.append(n), n;
+  }
+  updateScene(e) {
+    this.scene.attr({ ...e });
+    const { width: t, height: s } = e;
+    this.scene.width = t, this.scene.height = s, this.updateLayer({ width: t, height: s });
+  }
+  updateLayer(e) {
+    const { width: t, height: s } = e;
+    this.fullLayer.parent.setAttribute("width", t), this.fullLayer.parent.setAttribute("height", s), this.fullLayer.setAttribute("size", [t, s]), this.fullLayer.setAttribute("pos", [t * 0.5, s * 0.5]);
+  }
+  destroy(e) {
+    if (this.destroyed) return;
+    e && this.activeRequest && this.reportRequestFailure(
+      this.activeRequest.business,
+      this.activeRequest.requestId,
+      this.activeRequest.scenePath,
+      new Error(`snapshot request ${e}`),
+      e
+    ), this.activeRequest = void 0, this.destroyed = !0, this.mainThreadPostId !== void 0 && (cancelAnimationFrame(this.mainThreadPostId), this.mainThreadPostId = void 0), this.releaseBatchImageBitmaps({
+      sp: [...this.combinePostMsg].flatMap((r) => r.sp || [])
+    }), this.combinePostMsg.clear();
+    const t = [];
+    this.workShapes.forEach((r) => {
+      try {
+        r.clearTmpPoints();
+      } catch (i) {
+        t.push(i);
+      }
+    }), this.workShapes.clear();
+    try {
+      this.clearCacheImages();
+    } catch (r) {
+      t.push(r);
+    }
+    try {
+      this.clearImageResolveMap();
+    } catch (r) {
+      t.push(r);
+    }
+    const s = this.fullLayer.parent;
+    try {
+      this.fullLayer.remove();
+    } catch (r) {
+      t.push(r);
+    }
+    try {
+      s && z(this.fullLayer, s);
+    } catch (r) {
+      t.push(r);
+    }
+    try {
+      this.scene.remove();
+    } catch (r) {
+      t.push(r);
+    }
+    if (t.length)
+      throw t[0];
+  }
+}
+class lt {
+  constructor(e) {
+    u(this, "mainThreadMap", /* @__PURE__ */ new Map());
+    u(this, "cameraRenderQueueByView", /* @__PURE__ */ new Map());
+    u(this, "viewGenerationById", /* @__PURE__ */ new Map());
+    u(this, "viewOwnerById", /* @__PURE__ */ new Map());
+    u(this, "ownerSequence", 0);
+    u(this, "snapshotThreadsByRequest", /* @__PURE__ */ new Map());
+    u(this, "destroyed", !1);
+    u(this, "master");
+    u(this, "post", (e) => {
+      if (this.destroyed) {
+        this.releaseBatchResources(e);
+        return;
+      }
+      if (e.viewId) {
+        const f = this.viewOwnerById.get(e.viewId), w = this.viewGenerationById.get(e.viewId);
+        if (e.viewOwner !== void 0 && (!f || f !== e.viewOwner) || e.viewGeneration !== void 0 && w !== void 0 && w !== e.viewGeneration) {
+          this.releaseBatchResources(e);
+          return;
+        }
+      }
+      const {
+        fullWorkerDrawCount: t,
+        sp: s,
+        workerTasksqueueCount: r,
+        cameraTaskId: i,
+        cameraTaskStatus: o,
+        cameraTaskError: a,
+        cameraSettledTaskId: n,
+        viewId: c,
+        viewGeneration: d,
+        consumeCount: l,
+        consumeWorkId: p
+      } = e;
+      if (c && q(i)) {
+        const f = Be(
+          o,
+          a,
+          "mainThread"
+        );
+        f ? this.master.failCameraTask(
+          c,
+          i,
+          f,
+          d
+        ) : this.master.ackCameraTask(c, i, d);
+      }
+      c && q(n) && this.master.ackCameraSettledTask(
+        c,
+        n,
+        d
+      ), this.master.isBusy && q(r) && this.master.setWorkerTasksqueueCount(r), q(t) && this.master.setMaxDrawCount(t), q(l) && this.master.setConsumeCount(l, p), s && this.master.collectorSyncData(
+        e.viewOwner === void 0 ? s : s.map(
+          (f) => f.type === h.GetImageBitMap && f.viewOwner === void 0 ? { ...f, viewOwner: e.viewOwner } : f
+        )
+      );
+    });
+    this.master = e;
+  }
+  enqueueViewTask(e, t) {
+    const r = (this.cameraRenderQueueByView.get(e) || Promise.resolve()).catch(() => {
+    }).then(() => this.destroyed ? void 0 : t());
+    return this.cameraRenderQueueByView.set(e, r), r;
+  }
+  isStaleViewMessage(e) {
+    if (!e.viewId || e.viewId === ce || e.viewGeneration === void 0)
+      return !1;
+    const t = this.viewGenerationById.get(e.viewId);
+    return t !== void 0 && e.viewGeneration < t;
+  }
+  discardView(e) {
+    for (const [s, r] of [
+      ...this.snapshotThreadsByRequest.entries()
+    ])
+      r.thread.viewId === e && this.disposeSnapshotThread(
+        s,
+        r.thread,
+        "view-destroyed"
+      );
+    const t = this.mainThreadMap.get(e);
+    try {
+      t == null || t.destroy();
+    } catch (s) {
+      this.master.Logger.error(
+        `[Appliance]: MainThread View discard failed; viewId=${e}; error=${s instanceof Error ? s.message : String(s)}`
+      );
+    }
+    this.mainThreadMap.delete(e), this.cameraRenderQueueByView.delete(e), this.viewOwnerById.delete(e), this.viewGenerationById.set(
+      e,
+      (this.viewGenerationById.get(e) || 0) + 1
+    );
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = !0;
+    const e = [];
+    for (const [t, s] of [
+      ...this.snapshotThreadsByRequest.entries()
+    ])
+      try {
+        this.disposeSnapshotThread(t, s.thread);
+      } catch (r) {
+        e.push(
+          `snapshot-thread: ${r instanceof Error ? r.message : String(r)}`
+        );
+      }
+    this.snapshotThreadsByRequest.clear();
+    for (const t of this.mainThreadMap.values())
+      try {
+        t.destroy();
+      } catch (s) {
+        e.push(
+          `view=${t.viewId}: ${s instanceof Error ? s.message : String(s)}`
+        );
+      }
+    this.mainThreadMap.clear(), this.cameraRenderQueueByView.clear(), this.viewOwnerById.clear(), e.length && this.master.Logger.error(
+      `[Appliance]: MainThread destroy completed with cleanup errors: ${e.join("; ")}`
+    );
+  }
+  createMainThread(e, t) {
+    return new je(e, t);
+  }
+  createSnapshotThread(e, t) {
+    return new Je(e, t);
+  }
+  getSnapshotRequestKey(e) {
+    return e.requestId || `${e.viewId}\0${e.scenePath || ""}\0${e.msgType}`;
+  }
+  disposeSnapshotThread(e, t, s) {
+    const r = this.snapshotThreadsByRequest.get(e);
+    if (!(!r || r.thread !== t)) {
+      this.snapshotThreadsByRequest.delete(e);
+      try {
+        t.destroy(s);
+      } finally {
+        r.surface.remove();
+      }
+    }
+  }
+  releaseMessageBitmap(e) {
+    var t;
+    try {
+      (t = e.imageBitmap) == null || t.close();
+    } catch {
+    }
+  }
+  releaseBatchResources(e) {
+    var t, s;
+    (t = e.render) == null || t.forEach((r) => this.releaseImageBitmap(r.imageBitmap)), (s = e.sp) == null || s.forEach((r) => this.releaseImageBitmap(r.imageBitmap));
+  }
+  releaseImageBitmap(e) {
+    var t;
+    try {
+      (t = e == null ? void 0 : e.close) == null || t.call(e);
+    } catch {
+    }
+  }
+  async consume(e) {
+    var t, s, r;
+    if (this.destroyed) {
+      e.forEach((i) => this.releaseMessageBitmap(i));
+      return;
+    }
+    for (const i of e.values()) {
+      if (this.destroyed) {
+        this.releaseMessageBitmap(i);
+        return;
+      }
+      const {
+        msgType: o,
+        viewId: a,
+        tasksqueue: n,
+        mainTasksqueueCount: c,
+        cameraTaskId: d,
+        layerOpt: l,
+        offscreenCanvasOpt: p,
+        cameraOpt: f,
+        isSubWorker: w
+      } = i;
+      if (this.isStaleViewMessage(i)) {
+        this.releaseMessageBitmap(i);
+        continue;
+      }
+      if (o === h.Console) {
+        console.log(this);
+        continue;
+      }
+      if (o === h.Init) {
+        const g = i.viewGeneration ?? (this.viewGenerationById.get(a) || 0) + 1;
+        await this.enqueueViewTask(a, async () => {
+          var E, v, O;
+          const y = this.viewGenerationById.get(a);
+          if (y !== void 0 && g < y)
+            return;
+          this.viewGenerationById.set(a, g);
+          const S = i.viewOwner || `${a}:${g}:${++this.ownerSequence}`, T = (E = this.master.control.viewContainerManager.getView(a)) == null ? void 0 : E.displayer, C = T == null ? void 0 : T.canvasContainerRef.current;
+          if (!T || !C || !l || !p) {
+            this.viewOwnerById.delete(a);
+            return;
+          }
+          this.viewOwnerById.set(a, S);
+          const L = this.mainThreadMap.get(a);
+          L == null || L.destroy();
+          const A = this.createMainThread(a, {
+            displayer: T,
+            container: C,
+            layerOpt: l,
+            master: this.master,
+            canvasOpt: p,
+            viewOwner: S,
+            viewGeneration: g,
+            mainThreadRenderMode: ((O = (v = this.master.control) == null ? void 0 : v.renderingCompatibilityDecision) == null ? void 0 : O.mainThreadRenderMode) ?? "normal",
+            post: (B) => this.post({
+              ...B,
+              viewId: B.viewId || a,
+              viewGeneration: B.viewGeneration ?? g,
+              viewOwner: S
+            })
+          });
+          this.mainThreadMap.set(a, A), A && f && A.setCameraOpt(f), this.post({
+            sp: [
+              {
+                type: h.Init,
+                viewId: a,
+                viewGeneration: g
+              }
+            ]
+          });
+        });
+        continue;
+      }
+      if (o === h.Snapshot || o === h.BoundingBox) {
+        const g = (t = this.master.control.viewContainerManager.getView(a)) == null ? void 0 : t.displayer, y = (s = this.master.control.viewContainerManager.mainView) == null ? void 0 : s.displayer, S = (r = y == null ? void 0 : y.snapshotContainerRef) == null ? void 0 : r.current;
+        if (g && S && f) {
+          const T = this.getSnapshotRequestKey(i), C = this.snapshotThreadsByRequest.get(T);
+          C && this.disposeSnapshotThread(T, C.thread, "replaced");
+          const L = document.createElement("div");
+          L.style.width = `${f.width}px`, L.style.height = `${f.height}px`, S.append(L);
+          const A = {
+            ...he.defaultLayerOpt,
+            offscreen: !1,
+            width: f.width,
+            height: f.height
+          }, E = {
+            ...he.defaultScreenCanvasOpt,
+            width: f.width,
+            height: f.height
+          }, v = this.createSnapshotThread(a, {
+            displayer: g,
+            container: L,
+            layerOpt: A,
+            master: this.master,
+            canvasOpt: E,
+            post: this.post,
+            viewOwner: this.viewOwnerById.get(a),
+            viewGeneration: this.viewGenerationById.get(a)
+          });
+          this.snapshotThreadsByRequest.set(T, {
+            thread: v,
+            surface: L
+          }), v.on(i).then(() => {
+            this.disposeSnapshotThread(T, v);
+          }).catch((O) => {
+            this.master.Logger.error(
+              `[Appliance]: snapshot render failed; viewId=${a}; error=${O instanceof Error ? O.message : String(O)}`
+            ), this.disposeSnapshotThread(T, v);
+          });
+          continue;
+        }
+        this.post({
+          viewId: a,
+          viewGeneration: this.viewGenerationById.get(a),
+          viewOwner: this.viewOwnerById.get(a),
+          sp: [
+            {
+              type: h.ReportError,
+              viewId: a,
+              scenePath: i.scenePath,
+              requestId: i.requestId,
+              reportBusiness: o === h.Snapshot ? "snapshot" : "bounding-box",
+              reportStage: "surface-unavailable",
+              reportError: "snapshot surface is unavailable",
+              reportString: `[MainThreadManager] ${o === h.Snapshot ? "snapshot" : "bounding-box"} surface is unavailable; viewId=${a}; requestId=${i.requestId || "unknown"}`
+            }
+          ]
+        });
+        continue;
+      }
+      if (o === h.GetImageBitMap && w) {
+        const g = i.requestId ? this.snapshotThreadsByRequest.get(i.requestId) : [...this.snapshotThreadsByRequest.values()].find(
+          ({ thread: y }) => y.viewId === a
+        );
+        g ? g.thread.on(i) : this.releaseMessageBitmap(i);
+        continue;
+      }
+      if (o === h.GetImageBitMap) {
+        const g = this.mainThreadMap.get(a), y = this.viewGenerationById.get(a), S = this.viewOwnerById.get(a);
+        if (!g || i.viewGeneration !== void 0 && i.viewGeneration !== y || i.viewOwner !== void 0 && i.viewOwner !== S || this.mainThreadMap.get(a) !== g) {
+          this.releaseMessageBitmap(i);
+          continue;
+        }
+        await g.on(i);
+        continue;
+      }
+      if (o === h.TasksQueue && (n != null && n.size)) {
+        const g = n.get(a), y = this.mainThreadMap.get(a), S = this.viewGenerationById.get(a), T = this.viewOwnerById.get(a);
+        let C;
+        if (g && y)
+          try {
+            await this.enqueueViewTask(a, async () => {
+              this.viewGenerationById.get(a) !== S || this.viewOwnerById.get(a) !== T || this.mainThreadMap.get(a) !== y || await y.on(g);
+            });
+          } catch (L) {
+            if (g.msgType !== h.UpdateCamera) throw L;
+            const A = De(L);
+            C = {
+              code: A ? "RENDERER_BUSINESS_TIMEOUT" : "RENDERER_BUSINESS_ERROR",
+              business: "updateCamera",
+              message: L instanceof Error ? L.message : String(L),
+              elapsedMs: A ? L.elapsedMs : void 0,
+              stage: A ? L.stage : "update-camera",
+              blockingWorks: A ? L.blockingWorks : void 0,
+              workerType: "mainThread"
+            };
+          }
+        if (C && q(d)) {
+          this.post({
+            viewId: a,
+            viewGeneration: S,
+            viewOwner: T,
+            cameraTaskId: d,
+            cameraTaskStatus: C.code === "RENDERER_BUSINESS_TIMEOUT" ? "timeout" : "failed",
+            cameraTaskError: C
+          });
+          continue;
+        }
+        c && q(d) && this.post({
+          workerTasksqueueCount: c,
+          cameraTaskId: d,
+          viewId: a,
+          viewGeneration: S,
+          viewOwner: T
+        });
+        continue;
+      }
+      if (a === ce) {
+        const g = [...this.mainThreadMap.entries()];
+        for (const [y, S] of g) {
+          const T = this.enqueueViewTask(y, async () => {
+            this.mainThreadMap.get(y) === S && (o === h.Destroy ? (S.destroy(), this.mainThreadMap.delete(y), this.viewOwnerById.delete(y), this.viewGenerationById.set(
+              y,
+              (this.viewGenerationById.get(y) || 0) + 1
+            )) : await S.on(i));
+          });
+          await T, this.cameraRenderQueueByView.get(y) === T && this.cameraRenderQueueByView.delete(y);
+        }
+        continue;
+      }
+      const k = this.mainThreadMap.get(a);
+      if (o === h.Destroy && !k) {
+        await this.enqueueViewTask(a, async () => {
+          this.viewGenerationById.set(
+            a,
+            i.viewGeneration ?? (this.viewGenerationById.get(a) || 0) + 1
+          ), this.viewOwnerById.delete(a);
+        });
+        continue;
+      }
+      if (!k)
+        continue;
+      const I = this.viewGenerationById.get(a), W = this.enqueueViewTask(a, async () => {
+        this.viewGenerationById.get(a) !== I || this.mainThreadMap.get(a) !== k || await k.on(i);
+      });
+      o === h.Destroy && (await W, this.mainThreadMap.get(a) === k && this.mainThreadMap.delete(a), this.viewOwnerById.delete(a), this.cameraRenderQueueByView.get(a) === W && this.cameraRenderQueueByView.delete(a), this.viewGenerationById.set(
+        a,
+        i.viewGeneration ?? (I || 0) + 1
+      ));
+    }
+  }
+}
+export {
+  lt as MainThreadManagerImpl
+};