@netless/appliance-plugin 1.1.18 → 1.1.19-beta.2

package/dist/index-DM5jr5_3.mjs

@@ -0,0 +1,2776 @@
+var ne = Object.defineProperty;
+var ce = (b, t, e) => t in b ? ne(b, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : b[t] = e;
+var d = (b, t, e) => ce(b, typeof t != "symbol" ? t + "" : t, e);
+import { D as B, E as g, a as k, r as U, b as I, g as H, t as P, c as p, S as te, d as L, e as $, i as le, C as x, f as A, h as he, j as X, k as T, M as F, V as pe, l as se, T as Y, m as q, n as Q, o as G, p as de, q as V, s as J, u as ue } from "./index-BJkvFhzU.mjs";
+import { Scene as oe, Group as re } from "spritejs";
+import { cloneDeep as ie, xor as fe, isNumber as _, isEqual as ee } from "lodash";
+import "clipper-lib";
+import "lineclip";
+import "white-web-sdk";
+import "react-dom";
+import "react";
+import "eventemitter2";
+class me {
+  constructor(t) {
+    d(this, "vNodes");
+    d(this, "thread");
+    d(this, "serviceWorkShapes", /* @__PURE__ */ new Map());
+    d(this, "localWorkShapes", /* @__PURE__ */ new Map());
+    d(this, "tmpOpt");
+    d(this, "animationId");
+    d(this, "syncUnitTime", B.syncOpt.interval);
+    this.vNodes = t.vNodes, this.thread = t.thread;
+  }
+  createLocalWork(t) {
+    const { workId: e, opt: s, toolsType: o } = t;
+    if (e && s) {
+      const r = e.toString();
+      !this.getToolsOpt() && o && this.setToolsOpt({
+        toolsType: o,
+        toolsOpt: s
+      }), this.setWorkOptions(r, s);
+    }
+  }
+  getLocalWorkShape(t) {
+    return this.localWorkShapes.get(t);
+  }
+  createLocalWorkShape(t, e) {
+    if (t && this.tmpOpt) {
+      const s = {
+        toolsType: this.tmpOpt.toolsType,
+        toolsOpt: e || this.tmpOpt.toolsOpt
+      }, o = this.createWorkShapeNode({ ...s, workId: t });
+      return o && this.localWorkShapes.set(t, {
+        node: o,
+        toolsType: o.toolsType,
+        workState: g.Start
+      }), o;
+    }
+  }
+  canUseTopLayer(t) {
+    return t === k.LaserPen;
+  }
+  destroy() {
+    this.clearAll();
+  }
+  clearAll() {
+    this.thread.topLayer.children.length && (this.thread.topLayer.parent.children.forEach((t) => {
+      t.name !== "viewport" && t.remove();
+    }), U(
+      this.thread.serviceLayer,
+      this.thread.serviceLayer.parent
+    )), this.serviceWorkShapes.clear(), this.localWorkShapes.clear();
+  }
+  consumeDraw(t) {
+    const { workId: e, dataType: s } = t;
+    if (s === I.Service)
+      this.activeServiceWorkShape(t);
+    else {
+      const o = e == null ? void 0 : e.toString(), r = o && this.localWorkShapes.get(o);
+      if (!r)
+        return;
+      const i = r.node.consume({
+        data: t,
+        isFullWork: !1,
+        isSubWorker: !0
+      });
+      i.rect && (r.result = i, r.workState = g.Doing, o && this.localWorkShapes.set(o, r));
+    }
+    this.runAnimation();
+  }
+  setToolsOpt(t) {
+    var e;
+    this.tmpOpt = t, (e = t.toolsOpt) != null && e.syncUnitTime && (this.syncUnitTime = t.toolsOpt.syncUnitTime);
+  }
+  getToolsOpt() {
+    return this.tmpOpt;
+  }
+  createWorkShapeNode(t) {
+    const { toolsType: e } = t;
+    if (e === k.LaserPen)
+      return H({
+        ...t,
+        vNodes: this.vNodes,
+        fullLayer: this.thread.topLayer,
+        drawLayer: this.thread.topLayer
+      });
+  }
+  setNodeKey(t, e, s, o) {
+    return e.toolsType = s, e.node = this.createWorkShapeNode({
+      workId: t,
+      toolsType: s,
+      toolsOpt: o
+    }), e;
+  }
+  activeServiceWorkShape(t) {
+    var f, m;
+    const { workId: e, opt: s, toolsType: o, type: r, updateNodeOpt: i, ops: c, op: n } = t;
+    if (!e)
+      return;
+    const a = e.toString(), h = (f = this.vNodes.get(a)) == null ? void 0 : f.rect;
+    if (!((m = this.serviceWorkShapes) != null && m.has(a))) {
+      let u = {
+        toolsType: o,
+        animationWorkData: n || [],
+        animationIndex: 0,
+        type: r,
+        updateNodeOpt: i,
+        ops: c,
+        oldRect: h
+      };
+      o && s && (u = this.setNodeKey(a, u, o, s)), this.serviceWorkShapes.set(a, u);
+    }
+    const l = this.serviceWorkShapes.get(a);
+    r && (l.type = r), c && (l.animationWorkData = P(c), l.ops = c), i && (l.updateNodeOpt = i), n && (l.animationWorkData = n), l.node && l.node.getWorkId() !== a && l.node.setWorkId(a), h && (l.oldRect = h), o && s && (l.toolsType !== o && o && s && this.setNodeKey(a, l, o, s), l.node && l.node.setWorkOptions(s));
+  }
+  computNextAnimationIndex(t, e) {
+    var r;
+    const s = ((r = t.node) == null ? void 0 : r.syncUnitTime) || this.syncUnitTime, o = Math.floor(
+      (t.animationWorkData || []).slice(t.animationIndex).length * 32 / e / s
+    ) * e;
+    return Math.min(
+      (t.animationIndex || 0) + (o || e),
+      (t.animationWorkData || []).length
+    );
+  }
+  animationDraw() {
+    var o, r, i, c;
+    this.animationId = void 0;
+    let t = !1;
+    const e = /* @__PURE__ */ new Map(), s = [];
+    for (const [n, a] of this.serviceWorkShapes.entries())
+      switch (a.toolsType) {
+        case k.LaserPen: {
+          const l = this.computNextAnimationIndex(
+            a,
+            8
+          ), f = Math.max(0, a.animationIndex || 0), m = (a.animationWorkData || []).slice(
+            f,
+            l
+          );
+          if ((a.animationIndex || 0) < l && ((o = a.node) == null || o.consumeService({
+            op: m,
+            isFullWork: !1
+          }), a.animationIndex = l, m.length && e.set(n, {
+            workState: f === 0 ? g.Start : l === ((r = a.animationWorkData) == null ? void 0 : r.length) ? g.Done : g.Doing,
+            op: m.slice(-2)
+          })), a.isDel) {
+            (i = a.node) == null || i.clearTmpPoints(), this.serviceWorkShapes.delete(n);
+            break;
+          }
+          a.ops && a.animationIndex === ((c = a.animationWorkData) == null ? void 0 : c.length) && !a.isDel && (this.thread.topLayer.getElementsByName(
+            n.toString()
+          )[0] || (a.isDel = !0, this.serviceWorkShapes.set(n, a))), t = !0;
+          break;
+        }
+      }
+    for (const [n, a] of this.localWorkShapes.entries()) {
+      const { result: h, toolsType: l, isDel: f, workState: m } = a;
+      switch (l) {
+        case k.LaserPen: {
+          if (f) {
+            a.node.clearTmpPoints(), this.localWorkShapes.delete(n), s.push({
+              removeIds: [n.toString()],
+              type: p.RemoveNode
+            });
+            break;
+          }
+          h && ((h.op || h.ops) && s.push(h), a.result = void 0), !this.thread.topLayer.getElementsByName(
+            n.toString()
+          )[0] && m === g.Done && (a.isDel = !0, this.localWorkShapes.set(n, a)), t = !0;
+          break;
+        }
+      }
+    }
+    t && this.runAnimation(), e.size && e.forEach((n, a) => {
+      s.push({
+        type: p.Cursor,
+        uid: a.split(te)[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(t, e) {
+    var o;
+    let s = (o = this.localWorkShapes.get(t)) == null ? void 0 : o.node;
+    if (!s && this.tmpOpt) {
+      const { toolsType: r } = this.tmpOpt;
+      this.tmpOpt.toolsOpt = e, s = this.createWorkShapeNode({ workId: t, toolsType: r, toolsOpt: e }), s && this.localWorkShapes.set(t, {
+        node: s,
+        toolsType: r,
+        workState: g.Start
+      }), this.setToolsOpt(this.tmpOpt);
+    }
+    e != null && e.syncUnitTime || (e.syncUnitTime = this.syncUnitTime), s && s.setWorkOptions(e);
+  }
+  consumeDrawAll(t) {
+    const { workId: e, dataType: s } = t;
+    if (s === I.Service)
+      this.activeServiceWorkShape(t);
+    else {
+      const o = e == null ? void 0 : e.toString(), r = o && this.localWorkShapes.get(o);
+      if (!r)
+        return;
+      const i = r.node.consumeAll({ data: t });
+      r.result = i, r.workState = g.Done, o && this.localWorkShapes.set(o, r);
+    }
+    this.runAnimation();
+  }
+}
+class ke {
+  constructor(t) {
+    d(this, "vNodes");
+    d(this, "thread");
+    d(this, "workShapes", /* @__PURE__ */ new Map());
+    d(this, "effectSelectNodeData", /* @__PURE__ */ new Set());
+    d(this, "batchEraserRemoveNodes", /* @__PURE__ */ new Set());
+    d(this, "batchEraserWorks", /* @__PURE__ */ new Set());
+    d(this, "tmpOpt");
+    d(this, "syncUnitTime", B.syncOpt.interval);
+    d(this, "fullWorkerDrawCount", 0);
+    d(this, "drawWorkActiveId");
+    d(this, "consumeCount", 0);
+    d(this, "combineTimerId");
+    d(this, "combineDrawResolve");
+    d(this, "combineDrawActiveId");
+    this.vNodes = t.vNodes, this.thread = t.thread;
+  }
+  async loadImageBitMap(t) {
+    return await this.thread.loadImageBitMap(t);
+  }
+  createLocalWork(t) {
+    const { workId: e, opt: s, toolsType: o } = t;
+    if (e && s) {
+      const r = e.toString();
+      !this.getToolsOpt() && o && this.setToolsOpt({
+        toolsType: o,
+        toolsOpt: s
+      }), this.setWorkOptions(r, 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(t) {
+    var m;
+    const e = this.workShapes.get(
+      L
+    );
+    if (!((m = e == null ? void 0 : e.selectIds) != null && m.length)) return;
+    const { callback: s, ...o } = t, { updateSelectorOpt: r, willSerializeData: i, smoothSync: c } = o, n = await (e == null ? void 0 : e.updateSelector({
+      updateSelectorOpt: r,
+      selectIds: ie(e.selectIds),
+      vNodes: this.vNodes,
+      willSerializeData: i,
+      worker: this
+    })), a = /* @__PURE__ */ new Map();
+    let h;
+    n != null && n.selectIds && (h = fe(e.selectIds, n.selectIds), n.selectIds.forEach((u) => {
+      const S = this.vNodes.get(u);
+      if (S) {
+        const { toolsType: y, op: v, opt: W } = S;
+        a.set(u, {
+          opt: W,
+          toolsType: y,
+          ops: (v == null ? void 0 : v.length) && $(v) || void 0
+        });
+      }
+    }), e.selectIds = n.selectIds);
+    const l = [], f = s && s({
+      res: n,
+      workShapeNode: e,
+      param: o,
+      postData: { sp: l },
+      newServiceStore: a,
+      smoothSync: c
+    }) || { sp: l };
+    h && f.sp.push({
+      type: p.RemoveNode,
+      removeIds: h,
+      viewId: this.thread.viewId
+    }), f.sp.length && this.thread.post(f);
+  }
+  destroy() {
+    this.clearAll();
+  }
+  clearAll() {
+    if (this.thread.localLayer.children.length && (this.thread.topLayer.parent.children.forEach((e) => {
+      e.name !== "viewport" && e.remove();
+    }), U(
+      this.thread.localLayer,
+      this.thread.localLayer.parent
+    )), this.workShapes.get(
+      L
+    )) {
+      const e = [];
+      e.push({
+        type: p.Select,
+        dataType: I.Local,
+        selectIds: [],
+        willSyncService: !1
+      }), this.thread.post({ sp: e });
+    }
+    this.workShapes.clear(), this.effectSelectNodeData.clear(), this.batchEraserWorks.clear(), this.batchEraserRemoveNodes.clear();
+  }
+  async checkTextActive(t) {
+    const { op: e, viewId: s, dataType: o } = t;
+    if (e != null && e.length) {
+      let r;
+      for (const i of this.vNodes.curNodeMap.values()) {
+        const { rect: c, name: n, toolsType: a, opt: h } = i, l = e[0] * this.thread.fullLayer.worldScaling[0] + this.thread.fullLayer.worldPosition[0], f = e[1] * this.thread.fullLayer.worldScaling[1] + this.thread.fullLayer.worldPosition[1];
+        if (a === k.Text && le([l, f], c) && h.workState === g.Done) {
+          r = n;
+          break;
+        }
+      }
+      r && (await this.blurSelector({
+        viewId: s,
+        msgType: p.Select,
+        dataType: o,
+        isSync: !0
+      }), this.thread.post({
+        sp: [
+          {
+            type: p.GetTextActive,
+            toolsType: k.Text,
+            workId: r
+          }
+        ]
+      }));
+    }
+  }
+  cursorHover(t) {
+    const { opt: e, toolsType: s, point: o } = t, r = this.setFullWork({
+      workId: x,
+      toolsType: s,
+      opt: e
+    });
+    r && o && r.cursorHover(o);
+  }
+  cursorBlur() {
+    var e;
+    const t = this.getWorkShape(x);
+    t && ((e = t.selectIds) != null && e.length) && (t.cursorBlur(), this.clearWorkShapeNodeCache(x)), this.thread.fullLayer.parent.children.forEach((s) => {
+      s.name === "Cursor_Hover_Id" && s.remove();
+    });
+  }
+  updateFullSelectWork(t) {
+    var o, r, i, c, n;
+    const e = this.workShapes.get(
+      L
+    ), { selectIds: s } = t;
+    if (!(s != null && s.length)) {
+      this.blurSelector(t);
+      return;
+    }
+    if (!e) {
+      const a = this.setFullWork(t);
+      !a && t.workId && this.tmpOpt && ((o = this.tmpOpt) == null ? void 0 : o.toolsType) === k.Selector && this.setWorkOptions(
+        t.workId.toString(),
+        t.opt || this.tmpOpt.toolsOpt
+      ), a && this.updateFullSelectWork(t);
+      return;
+    }
+    if (e && (s != null && s.length)) {
+      const { selectRect: a } = e.updateSelectIds(s), h = [
+        {
+          ...t,
+          selectorColor: ((r = t.opt) == null ? void 0 : r.strokeColor) || e.selectorColor,
+          strokeColor: ((i = t.opt) == null ? void 0 : i.strokeColor) || e.strokeColor,
+          fillColor: ((c = t.opt) == null ? void 0 : c.fillColor) || e.fillColor,
+          textOpt: ((n = t.opt) == null ? void 0 : n.textOpt) || e.textOpt,
+          canTextEdit: e.canTextEdit,
+          canRotate: e.canRotate,
+          scaleType: e.scaleType,
+          type: p.Select,
+          selectRect: a,
+          points: e.getChildrenPoints(),
+          willSyncService: (t == null ? void 0 : t.willSyncService) || !1,
+          opt: (t == null ? void 0 : t.willSyncService) && e.getWorkOptions() || void 0,
+          canLock: e.canLock,
+          isLocked: e.isLocked,
+          toolsTypes: e.toolsTypes,
+          shapeOpt: e.shapeOpt,
+          thickness: e.thickness,
+          useStroke: e.useStroke,
+          strokeType: e.strokeType
+        }
+      ];
+      this.thread.post({ sp: h });
+    }
+  }
+  commandDeleteText(t) {
+    const e = this.vNodes.get(t);
+    if (e && e.toolsType === k.Text)
+      return {
+        type: p.TextUpdate,
+        toolsType: k.Text,
+        workId: t,
+        dataType: I.Local
+      };
+  }
+  async removeSelector(t) {
+    const { willSyncService: e } = t, s = [], o = [], r = this.workShapes.get(
+      L
+    );
+    if (!r)
+      return;
+    const i = r.selectIds && [...r.selectIds] || [];
+    for (const c of i) {
+      if (this.vNodes.get(c)) {
+        const a = this.commandDeleteText(c);
+        a && s.push(a);
+      }
+      this.removeNode(c), o.push(c);
+    }
+    o.length && s.push({
+      type: p.RemoveNode,
+      removeIds: o
+    }), s.push({
+      type: p.Select,
+      selectIds: [],
+      willSyncService: e
+    }), await this.blurSelector(), s.length && this.thread.post({ sp: s });
+  }
+  removeWork(t) {
+    const { workId: e } = t, s = e == null ? void 0 : e.toString();
+    s && this.removeNode(s);
+  }
+  removeNode(t) {
+    var o;
+    this.vNodes.get(t) && ((o = this.thread.fullLayer) == null || o.getElementsByName(t).forEach((r) => {
+      r.remove(), A(r, this.thread.fullLayer.parent);
+    }), this.vNodes.delete(t)), this.workShapes.has(t) && (this.thread.localLayer.getElementsByName(t).forEach((r) => {
+      r.remove(), A(r, this.thread.localLayer.parent);
+    }), this.clearWorkShapeNodeCache(t));
+  }
+  setFullWork(t) {
+    const { workId: e, opt: s, toolsType: o } = t;
+    if (e && s && o) {
+      const r = e.toString();
+      let i;
+      return e && this.workShapes.has(r) ? (i = this.workShapes.get(r), i == null || i.setWorkOptions(s)) : i = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: o,
+        workId: r
+      }), i ? (this.workShapes.set(r, i), i) : void 0;
+    }
+  }
+  async consumeFull(t) {
+    var o;
+    const e = this.setFullWork(t), s = t.ops && P(t.ops);
+    if (e) {
+      const r = (o = t.workId) == null ? void 0 : o.toString();
+      e.toolsType === k.Image ? await e.consumeServiceAsync({
+        isFullWork: !0,
+        replaceId: r,
+        worker: this
+      }) : e.toolsType === k.Text ? await e.consumeServiceAsync({
+        isFullWork: !0,
+        replaceId: r
+      }) : e.consumeService({
+        op: s,
+        isFullWork: !0,
+        replaceId: r
+      }), t != null && t.updateNodeOpt && e.updataOptService(t.updateNodeOpt);
+      const i = [];
+      t.workId && this.workShapes.delete(t.workId.toString()), t.willSyncService && i.push({
+        opt: t.opt,
+        toolsType: t.toolsType,
+        type: p.FullWork,
+        workId: t.workId,
+        ops: t.ops,
+        updateNodeOpt: t.updateNodeOpt,
+        viewId: this.thread.viewId
+      }), i.length && this.thread.post({ sp: i });
+    }
+  }
+  async colloctEffectSelectWork(t) {
+    const e = this.workShapes.get(
+      L
+    ), { workId: s, msgType: o } = t;
+    if (e && s && e.selectIds && e.selectIds.includes(s.toString())) {
+      o === p.RemoveNode ? e.selectIds = e.selectIds.filter(
+        (r) => r !== s.toString()
+      ) : this.effectSelectNodeData.add(t), await new Promise((r) => {
+        setTimeout(() => {
+          r(!0);
+        }, 0);
+      }), await this.runEffectSelectWork(!0).then(() => {
+        var r;
+        (r = this.effectSelectNodeData) == null || r.clear();
+      });
+      return;
+    }
+    return t;
+  }
+  async runEffectSelectWork(t) {
+    var e;
+    for (const s of this.effectSelectNodeData.values()) {
+      const o = this.setFullWork(s);
+      if (o) {
+        const r = (e = s.workId) == null ? void 0 : e.toString();
+        if (o.toolsType === k.Image)
+          await o.consumeServiceAsync({
+            isFullWork: !0,
+            replaceId: r,
+            worker: this
+          });
+        else if (o.toolsType === k.Text)
+          await o.consumeServiceAsync({
+            isFullWork: !0,
+            replaceId: r
+          });
+        else {
+          const i = s.ops && P(s.ops);
+          o.consumeService({
+            op: i,
+            isFullWork: !0,
+            replaceId: r
+          }), s != null && s.updateNodeOpt && o.updataOptService(s.updateNodeOpt);
+        }
+        s.workId && this.workShapes.delete(s.workId.toString());
+      }
+    }
+    this.reRenderSelector(t);
+  }
+  hasSelector() {
+    return this.workShapes.has(L);
+  }
+  getSelector() {
+    return this.workShapes.get(L);
+  }
+  reRenderSelector(t = !1) {
+    var o;
+    const e = this.workShapes.get(
+      L
+    );
+    if (!e) return;
+    if (e && !((o = e.selectIds) != null && o.length))
+      return this.blurSelector();
+    const s = e.reRenderSelector();
+    s && this.thread.post({
+      sp: [
+        {
+          type: p.Select,
+          selectIds: e.selectIds,
+          selectRect: s,
+          willSyncService: t,
+          viewId: this.thread.viewId,
+          points: e.getChildrenPoints(),
+          textOpt: e.textOpt,
+          selectorColor: e.selectorColor,
+          strokeColor: e.strokeColor,
+          fillColor: e.fillColor,
+          canTextEdit: e.canTextEdit,
+          canRotate: e.canRotate,
+          scaleType: e.scaleType,
+          opt: e.getWorkOptions() || void 0,
+          canLock: e.canLock,
+          isLocked: e.isLocked,
+          toolsTypes: e.toolsTypes,
+          shapeOpt: e.shapeOpt,
+          thickness: e.thickness,
+          useStroke: e.useStroke,
+          strokeType: e.strokeType
+        }
+      ]
+    });
+  }
+  async blurSelector(t) {
+    var o;
+    const e = this.workShapes.get(
+      L
+    ), s = e == null ? void 0 : e.blurSelector();
+    if (this.clearWorkShapeNodeCache(L), ((o = this.thread.fullLayer) == null ? void 0 : o.parent).children.forEach((r) => {
+      r.name === L && r.remove();
+    }), s) {
+      const r = [];
+      r.push({
+        ...s,
+        isSync: t == null ? void 0 : t.isSync
+      }), this.thread.post({ sp: r });
+    }
+  }
+  clearWorkShapeNodeCache(t) {
+    var e;
+    (e = this.getWorkShape(t)) == null || e.clearTmpPoints(), this.workShapes.delete(t);
+  }
+  async drawBitMapEraserFull(t, e, s) {
+    const { willUpdateNodes: o, willDeleteNodes: r } = e, i = t.getWorkId(), c = [
+      {
+        type: p.RemoveNode,
+        removeIds: [i],
+        viewId: this.thread.viewId
+      }
+    ];
+    if (s && c.push({
+      type: p.None,
+      isLockSentEventCursor: s
+    }), o != null && o.size || r != null && r.size) {
+      if (o != null && o.size)
+        for (const [n, a] of o)
+          c.push({
+            type: p.UpdateNode,
+            dataType: I.Local,
+            opt: a.opt,
+            workId: n,
+            updateNodeOpt: {
+              useAnimation: !1
+            }
+          });
+      r != null && r.size && c.push({
+        type: p.RemoveNode,
+        removeIds: [...r],
+        viewId: this.thread.viewId
+      });
+    }
+    c.length && this.thread.post({ sp: c });
+  }
+  drawPencilEraserFull(t, e, s) {
+    const { willNewNodes: o, willDeleteNodes: r } = e, i = t.getWorkId(), c = [
+      {
+        type: p.RemoveNode,
+        removeIds: [i],
+        viewId: this.thread.viewId
+      }
+    ];
+    if (s && c.push({
+      type: p.None,
+      isLockSentEventCursor: s
+    }), o != null && o.size || r != null && r.size) {
+      if (o != null && o.size)
+        for (const [n, a] of o)
+          c.push({
+            type: p.FullWork,
+            dataType: I.Local,
+            toolsType: a.toolsType,
+            ops: $(a.op),
+            opt: a.opt,
+            workId: n,
+            updateNodeOpt: {
+              useAnimation: !1
+            }
+          });
+      r != null && r.size && c.push({
+        type: p.RemoveNode,
+        removeIds: [...r],
+        viewId: this.thread.viewId
+      });
+    }
+    c.length && this.thread.post({ sp: c });
+  }
+  drawEraser(t, e) {
+    const s = [];
+    t.removeIds && s.push(t), e && s.push({
+      type: p.None,
+      isLockSentEventCursor: e
+    }), this.thread.post({ sp: s, consumeCount: this.consumeCount });
+  }
+  getWorkShape(t) {
+    return this.workShapes.get(t);
+  }
+  getWorkShapes() {
+    return this.workShapes;
+  }
+  consumeDraw(t, e) {
+    const { op: s, workId: o, scenePath: r, postCount: i, smoothSync: c } = t;
+    if (s != null && s.length && o) {
+      const n = o.toString(), a = this.workShapes.get(n);
+      if (!a)
+        return;
+      const h = a.toolsType;
+      if (h === k.LaserPen)
+        return;
+      switch (this.combineDrawActiveId && this.combineDrawActiveId !== n && (this.combineTimerId && (clearTimeout(this.combineTimerId), this.combineTimerId = void 0, this.combineDrawResolve && this.combineDrawResolve(!1), this.combineDrawActiveId = void 0), this.consumeDrawAll(
+        {
+          workId: this.combineDrawActiveId,
+          scenePath: r,
+          viewId: this.thread.viewId,
+          msgType: p.DrawWork,
+          dataType: I.Local
+        },
+        e
+      )), this.drawWorkActiveId && this.drawWorkActiveId !== n && (this.consumeDrawAll(
+        {
+          workId: this.drawWorkActiveId,
+          scenePath: r,
+          viewId: this.thread.viewId,
+          msgType: p.DrawWork,
+          dataType: I.Local
+        },
+        e
+      ), this.drawWorkActiveId = void 0), !this.drawWorkActiveId && n !== L && (this.drawWorkActiveId = n), _(i) && (this.consumeCount = i), h) {
+        case k.Selector: {
+          const l = a.consume({
+            data: t,
+            isFullWork: !0,
+            isMainThread: !0
+          });
+          this.fullWorkerDrawCount++;
+          const f = [];
+          l.type === p.Select && (l.selectIds && e.runReverseSelectWork(l.selectIds), f.push(l)), this.thread.post({
+            consumeCount: this.consumeCount,
+            fullWorkerDrawCount: this.fullWorkerDrawCount,
+            sp: f
+          });
+          break;
+        }
+        case k.PencilEraser:
+        case k.BitMapEraser: {
+          a.consume({
+            data: t,
+            isFullWork: !1,
+            isMainThread: !0
+          }), this.fullWorkerDrawCount++, this.thread.post({
+            sp: void 0,
+            consumeCount: this.consumeCount,
+            fullWorkerDrawCount: this.fullWorkerDrawCount
+          }), this.combineTimerId || new Promise((l) => {
+            this.combineDrawActiveId = n, this.combineDrawResolve = l, this.combineTimerId = requestIdleCallback(
+              () => {
+                this.combineTimerId = void 0, this.combineDrawResolve && this.combineDrawResolve(!0);
+              },
+              { timeout: this.thread.master.maxCombineEraserTime }
+            );
+          }).then((l) => {
+            l && this.drawEraserCombine(n), this.combineDrawResolve = void 0;
+          });
+          break;
+        }
+        case k.Eraser:
+          {
+            const l = a.consume({
+              data: t,
+              isFullWork: !0
+            });
+            this.drawEraser(l);
+          }
+          break;
+        case k.Arrow:
+        case k.Straight:
+        case k.Ellipse:
+        case k.Rectangle:
+        case k.Star:
+        case k.Polygon:
+        case k.SpeechBalloon:
+        case k.Pencil:
+          {
+            const l = a.consume({
+              data: t,
+              isFullWork: !1,
+              isMainThread: !0,
+              smoothSync: c
+            });
+            l && (this.fullWorkerDrawCount++, this.thread.post({
+              consumeCount: this.consumeCount,
+              fullWorkerDrawCount: this.fullWorkerDrawCount,
+              sp: l.op && [{ ...l, scenePath: r }] || void 0
+            }));
+          }
+          break;
+      }
+    }
+  }
+  drawEraserCombine(t) {
+    var s, o, r, i;
+    const e = (s = this.workShapes.get(t)) == null ? void 0 : s.combineConsume({ workerEngine: this });
+    if (e) {
+      const { willDeleteNodes: c, willNewNodes: n } = e, a = {
+        render: [],
+        sp: []
+      };
+      if (e != null && e.rect) {
+        const h = he(e.rect);
+        (o = a.render) == null || o.push(
+          {
+            rect: h,
+            isClear: !0,
+            clearCanvas: X.Bg,
+            viewId: this.thread.viewId
+          },
+          {
+            rect: h,
+            drawCanvas: X.Bg,
+            viewId: this.thread.viewId
+          }
+        );
+      }
+      if (c != null && c.size && ((r = a.sp) == null || r.push({
+        type: p.RemoveNode,
+        removeIds: [...c],
+        viewId: this.thread.viewId
+      })), n != null && n.size)
+        for (const [h, l] of n)
+          (i = a.sp) == null || i.push({
+            type: p.FullWork,
+            dataType: I.Local,
+            toolsType: l.toolsType,
+            ops: $(l.op),
+            opt: l.opt,
+            workId: h,
+            updateNodeOpt: {
+              useAnimation: !1
+            }
+          });
+      this.thread.post(a);
+    }
+  }
+  consumeDrawAll(t, e) {
+    var i, c, n;
+    const { workId: s, scenePath: o, isLockSentEventCursor: r } = t;
+    if (s) {
+      this.combineTimerId && (clearTimeout(this.combineTimerId), this.combineTimerId = void 0, this.combineDrawResolve && this.combineDrawResolve(!1), this.combineDrawActiveId = void 0);
+      const a = s.toString();
+      this.drawWorkActiveId === a && (this.drawWorkActiveId = void 0);
+      const h = this.workShapes.get(a);
+      if (!h)
+        return;
+      const l = h.toolsType;
+      if (l === k.LaserPen)
+        return;
+      const f = this.workShapes.get(x), m = (i = f == null ? void 0 : f.selectIds) == null ? void 0 : i[0], u = h.consumeAll({ data: t, workerEngine: this });
+      switch (l) {
+        case k.Selector:
+          {
+            u.selectIds && m && ((c = u.selectIds) != null && c.includes(m)) && f.cursorBlur();
+            const S = [];
+            r && S.push({
+              type: p.None,
+              isLockSentEventCursor: r
+            }), u.type === p.Select && (u.selectIds && e.runReverseSelectWork(u.selectIds), S.push({ ...u, scenePath: o })), S.length && this.thread.post({ sp: S }), (n = h.selectIds) != null && n.length ? h.clearTmpPoints() : this.clearWorkShapeNodeCache(a);
+          }
+          break;
+        case k.PencilEraser:
+          this.drawPencilEraserFull(
+            h,
+            u,
+            r
+          ), this.fullWorkerDrawCount = 0, this.clearWorkShapeNodeCache(a);
+          break;
+        case k.BitMapEraser:
+          this.drawBitMapEraserFull(
+            h,
+            u,
+            r
+          ), this.fullWorkerDrawCount = 0, this.clearWorkShapeNodeCache(a);
+          break;
+        case k.Eraser:
+          this.drawEraser({ ...u, scenePath: o }, r), h.clearTmpPoints();
+          break;
+        case k.Arrow:
+        case k.Straight:
+        case k.Ellipse:
+        case k.Rectangle:
+        case k.Star:
+        case k.Polygon:
+        case k.SpeechBalloon:
+        case k.Pencil: {
+          const S = [];
+          r && S.push({
+            type: p.None,
+            isLockSentEventCursor: r
+          }), u && (S.push(u), this.fullWorkerDrawCount = 0, this.thread.post({
+            fullWorkerDrawCount: this.fullWorkerDrawCount,
+            sp: S
+          })), this.clearWorkShapeNodeCache(a);
+          break;
+        }
+      }
+    }
+  }
+  getToolsOpt() {
+    return this.tmpOpt;
+  }
+  setToolsOpt(t) {
+    var e;
+    this.tmpOpt = t, (e = t.toolsOpt) != null && e.syncUnitTime && (this.syncUnitTime = t.toolsOpt.syncUnitTime);
+  }
+  setWorkOptions(t, e) {
+    let s = this.workShapes.get(t);
+    if (!s && this.tmpOpt) {
+      const { toolsType: o } = this.tmpOpt;
+      this.tmpOpt.toolsOpt = e, s = this.createWorkShapeNode({ workId: t, toolsType: o, toolsOpt: e }), s && this.workShapes.set(t, s), this.setToolsOpt(this.tmpOpt);
+    }
+    e.syncUnitTime || (e.syncUnitTime = this.syncUnitTime), s == null || s.setWorkOptions(e);
+  }
+  createWorkShapeNode(t) {
+    return H(
+      {
+        ...t,
+        vNodes: this.vNodes,
+        fullLayer: this.thread.fullLayer,
+        drawLayer: this.thread.localLayer
+      },
+      this.thread.serviceWork
+    );
+  }
+}
+class Se {
+  constructor(t) {
+    d(this, "vNodes");
+    d(this, "thread");
+    d(this, "workShapes", /* @__PURE__ */ new Map());
+    d(this, "selectorWorkShapes", /* @__PURE__ */ new Map());
+    d(this, "willRunEffectSelectorIds", /* @__PURE__ */ new Set());
+    d(this, "runEffectId");
+    d(this, "animationId");
+    d(this, "syncUnitTime", B.syncOpt.interval);
+    this.vNodes = t.vNodes, this.thread = t.thread;
+  }
+  async loadImageBitMap(t) {
+    return await this.thread.loadImageBitMap(t);
+  }
+  destroy() {
+    this.clearAll();
+  }
+  clearAll() {
+    this.thread.serviceLayer.children.length && (this.thread.serviceLayer.parent.children.forEach((t) => {
+      t.name !== "viewport" && t.remove();
+    }), U(
+      this.thread.serviceLayer,
+      this.thread.serviceLayer.parent
+    )), this.workShapes.clear(), this.selectorWorkShapes.clear(), this.willRunEffectSelectorIds.clear();
+  }
+  runEffect() {
+    this.runEffectId || (this.runEffectId = setTimeout(
+      this.effectRunSelector.bind(this),
+      0
+    ));
+  }
+  effectRunSelector() {
+    this.runEffectId = void 0, this.willRunEffectSelectorIds.forEach((t) => {
+      var s, o;
+      const e = this.selectorWorkShapes.get(t);
+      e && e.selectIds && ((s = e.node) == null || s.selectServiceNode(
+        t,
+        e,
+        !0
+      )), (o = e == null ? void 0 : e.selectIds) != null && o.length || this.selectorWorkShapes.delete(t);
+    }), this.willRunEffectSelectorIds.clear();
+  }
+  runSelectWork(t) {
+    this.activeSelectorShape(t);
+    const { workId: e } = t, s = e == null ? void 0 : e.toString();
+    s && this.willRunEffectSelectorIds.add(s), this.runEffect();
+  }
+  removeWork(t) {
+    const { workId: e } = t, s = e == null ? void 0 : e.toString();
+    if (s) {
+      if (this.workShapes.get(s)) {
+        this.workShapes.delete(s), this.removeNode(s, t);
+        return;
+      }
+      this.removeNode(s, t);
+    }
+  }
+  consumeFull(t) {
+    this.activeWorkShape(t), this.runAnimation();
+  }
+  runReverseSelectWork(t) {
+    t.forEach((e) => {
+      this.selectorWorkShapes.forEach((s, o) => {
+        var r;
+        if ((r = s.selectIds) != null && r.length) {
+          const i = s.selectIds.indexOf(e);
+          i > -1 && (s.selectIds.splice(i, 1), this.willRunEffectSelectorIds.add(o));
+        }
+      });
+    }), this.willRunEffectSelectorIds.size && this.runEffect();
+  }
+  consumeDraw(t) {
+    this.activeWorkShape(t), this.runAnimation();
+  }
+  computNextAnimationIndex(t, e) {
+    const s = Math.floor(
+      (t.animationWorkData || []).slice(t.animationIndex).length * 32 / e / this.syncUnitTime
+    ) * e;
+    return Math.min(
+      (t.animationIndex || 0) + (s || e),
+      (t.animationWorkData || []).length
+    );
+  }
+  async animationDraw() {
+    var s, o, r, i, c, n, a, h, l, f, m, u, S, y, v, W, O, K, Z, j;
+    this.animationId = void 0;
+    let t = !1;
+    const e = /* @__PURE__ */ new Map();
+    for (const [N, w] of this.workShapes.entries())
+      switch (w.toolsType) {
+        case k.Image: {
+          await ((s = w.node) == null ? void 0 : s.consumeServiceAsync({
+            isFullWork: !0,
+            worker: this
+          })), this.selectorWorkShapes.forEach((D, C) => {
+            var E;
+            (E = D.selectIds) != null && E.includes(N) && (this.willRunEffectSelectorIds.add(C), this.runEffect());
+          }), this.workShapes.delete(N);
+          break;
+        }
+        case k.Text: {
+          w.node && (await ((o = w.node) == null ? void 0 : o.consumeServiceAsync({
+            isFullWork: !0,
+            replaceId: N
+          })), this.selectorWorkShapes.forEach((D, C) => {
+            var E;
+            (E = D.selectIds) != null && E.includes(N) && (this.willRunEffectSelectorIds.add(C), this.runEffect());
+          }), (r = w.node) == null || r.clearTmpPoints(), this.workShapes.delete(N));
+          break;
+        }
+        case k.Arrow:
+        case k.Straight:
+        case k.Rectangle:
+        case k.Ellipse:
+        case k.Star:
+        case k.Polygon:
+        case k.SpeechBalloon: {
+          const D = !!w.ops;
+          if ((i = w.animationWorkData) != null && i.length) {
+            const C = w.oldRect;
+            (c = w.node) == null || c.consumeService({
+              op: w.animationWorkData,
+              isFullWork: D
+            }), D && (this.selectorWorkShapes.forEach((E, M) => {
+              var z;
+              (z = E.selectIds) != null && z.includes(N) && (this.willRunEffectSelectorIds.add(M), this.runEffect());
+            }), (n = w.node) == null || n.clearTmpPoints(), this.workShapes.delete(N)), w.isEnableCursor ? e.set(N, {
+              workState: C ? w.ops ? g.Done : g.Doing : g.Start,
+              op: w.animationWorkData.slice(-3, -1)
+            }) : D && !w.useAnimation && ((a = w.updateNodeOpt) != null && a.useAnimation) && e.set(N, {
+              workState: g.Done,
+              op: w.animationWorkData.slice(-3, -1),
+              uid: (h = w.updateNodeOpt) == null ? void 0 : h.uid
+            }), w.animationWorkData.length = 0;
+          }
+          break;
+        }
+        case k.Pencil: {
+          if (w.useAnimation) {
+            if (w.useAnimation) {
+              if (w.isDel) {
+                (v = w.node) == null || v.clearTmpPoints(), this.workShapes.delete(N);
+                break;
+              }
+              const D = 3, C = this.computNextAnimationIndex(
+                w,
+                D
+              ), E = w.isDiff ? 0 : Math.max(0, (w.animationIndex || 0) - D), M = (w.animationWorkData || []).slice(
+                E,
+                C
+              ), z = (O = (W = w.node) == null ? void 0 : W.getWorkId()) == null ? void 0 : O.toString();
+              if ((w.animationIndex || 0) < C || w.isDiff) {
+                if ((K = w.node) == null || K.consumeService({
+                  op: M,
+                  isFullWork: !1
+                }), w.animationIndex = C, w.isDiff && (w.isDiff = !1), M.length && w.isEnableCursor) {
+                  const ae = M.slice(-3, -1);
+                  e.set(N, {
+                    workState: E === 0 ? g.Start : C === ((Z = w.animationWorkData) == null ? void 0 : Z.length) ? g.Done : g.Doing,
+                    op: ae
+                  });
+                }
+              } else w.ops && ((j = w.node) == null || j.consumeService({
+                op: w.animationWorkData || [],
+                isFullWork: !0,
+                replaceId: z
+              }), w.isDel = !0, w.isEnableCursor && e.set(N, {
+                workState: g.Done,
+                op: M.slice(-3, -1)
+              }));
+              t = !0;
+              break;
+            }
+          } else {
+            const D = !!w.ops;
+            if ((l = w.node) == null || l.consumeService({
+              op: w.animationWorkData || [],
+              isFullWork: D,
+              replaceId: N
+            }), (f = w.node) == null || f.updataOptService(w.updateNodeOpt), D) {
+              if (!w.isEnableCursor && ((m = w.updateNodeOpt) != null && m.useAnimation) && ((u = w.animationWorkData) != null && u.length)) {
+                const C = w.animationWorkData.slice(-3, -1);
+                e.set(N, {
+                  workState: g.Done,
+                  op: C,
+                  uid: (S = w.updateNodeOpt) == null ? void 0 : S.uid
+                });
+              }
+              this.selectorWorkShapes.forEach((C, E) => {
+                var M;
+                (M = C.selectIds) != null && M.includes(N) && (this.willRunEffectSelectorIds.add(E), this.runEffect());
+              }), (y = w.node) == null || y.clearTmpPoints(), this.workShapes.delete(N);
+            }
+          }
+          break;
+        }
+      }
+    if (t && this.runAnimation(), e.size) {
+      const N = [];
+      e.forEach((w, D) => {
+        N.push({
+          type: p.Cursor,
+          uid: w.uid || D.split(te)[0],
+          op: w.op,
+          workState: w.workState,
+          viewId: this.thread.viewId
+        });
+      }), this.thread.post({ sp: N });
+    }
+  }
+  runAnimation() {
+    this.animationId || (this.animationId = requestAnimationFrame(this.animationDraw.bind(this)));
+  }
+  hasDiffData(t, e, s) {
+    const o = t.length;
+    if (e.length < o)
+      return !0;
+    switch (s) {
+      case k.Pencil: {
+        for (let r = 0; r < o; r += 3)
+          if (e[r] !== t[r] || e[r + 1] !== t[r + 1])
+            return !0;
+        break;
+      }
+      case k.LaserPen: {
+        for (let r = 0; r < o; r += 2)
+          if (e[r] !== t[r] || e[r + 1] !== t[r + 1])
+            return !0;
+        break;
+      }
+    }
+    return !1;
+  }
+  activeWorkShape(t) {
+    var S, y, v, W;
+    const {
+      workId: e,
+      opt: s,
+      toolsType: o,
+      type: r,
+      updateNodeOpt: i,
+      ops: c,
+      op: n,
+      useAnimation: a,
+      imageBitmap: h,
+      isEnableCursor: l
+    } = t;
+    if (!e)
+      return;
+    const f = e.toString(), m = (S = this.vNodes.get(f)) == null ? void 0 : S.rect;
+    if (!((y = this.workShapes) != null && y.has(f))) {
+      let O = {
+        toolsType: o,
+        animationWorkData: n || [],
+        animationIndex: 0,
+        type: r,
+        updateNodeOpt: i,
+        ops: c,
+        useAnimation: typeof a < "u" ? a : typeof (i == null ? void 0 : i.useAnimation) < "u" ? i == null ? void 0 : i.useAnimation : !0,
+        oldRect: m,
+        isDiff: !1,
+        imageBitmap: h,
+        isEnableCursor: l
+      };
+      o && s && (O = this.setNodeKey(f, O, o, s)), (v = this.workShapes) == null || v.set(f, O);
+    }
+    const u = (W = this.workShapes) == null ? void 0 : W.get(f);
+    u.isEnableCursor = l, r && (u.type = r), c && (u.animationWorkData = P(c), u.ops = c), i && (u.updateNodeOpt = i), n && (u.isDiff = this.hasDiffData(
+      u.animationWorkData || [],
+      n,
+      u.toolsType
+    ), u.animationWorkData = n), u.node && u.node.getWorkId() !== f && u.node.setWorkId(f), m && (u.oldRect = m), o && s && (s.syncUnitTime && (this.syncUnitTime = s.syncUnitTime), u.toolsType !== o && o && s && this.setNodeKey(f, u, o, s), u.node && u.node.setWorkOptions(s)), h && (u.imageBitmap = h);
+  }
+  removeNode(t, e) {
+    t.indexOf(L) > -1 && this.removeSelectWork(e), this.thread.fullLayer.getElementsByName(t).forEach((s) => {
+      s.remove(), A(s, this.thread.fullLayer.parent);
+    }), this.thread.serviceLayer.getElementsByName(t).forEach((s) => {
+      s.remove(), A(s, this.thread.serviceLayer.parent);
+    }), this.vNodes.delete(t);
+  }
+  removeSelectWork(t) {
+    const { workId: e } = t, s = e == null ? void 0 : e.toString();
+    s && (this.activeSelectorShape(t), this.willRunEffectSelectorIds.add(s)), this.runEffect();
+  }
+  activeSelectorShape(t) {
+    var a, h, l;
+    const { workId: e, opt: s, toolsType: o, type: r, selectIds: i } = t;
+    if (!e)
+      return;
+    const c = e.toString();
+    if (!((a = this.selectorWorkShapes) != null && a.has(c))) {
+      let f = {
+        toolsType: o,
+        selectIds: i,
+        type: r,
+        opt: s
+      };
+      o && s && (f = this.setNodeKey(c, f, o, s)), (h = this.selectorWorkShapes) == null || h.set(c, f);
+    }
+    const n = (l = this.selectorWorkShapes) == null ? void 0 : l.get(c);
+    r && (n.type = r), n.node && n.node.getWorkId() !== c && n.node.setWorkId(c), n.selectIds = i || [];
+  }
+  setNodeKey(t, e, s, o) {
+    return e.toolsType = s, e.node = H(
+      {
+        toolsType: s,
+        toolsOpt: o,
+        vNodes: this.vNodes,
+        fullLayer: this.thread.fullLayer,
+        drawLayer: this.thread.serviceLayer,
+        workId: t
+      },
+      this
+    ), e;
+  }
+}
+class R {
+  constructor() {
+    d(this, "localWork");
+    d(this, "serviceWork");
+    d(this, "threadEngine");
+  }
+  registerMainThread(t) {
+    return this.threadEngine = t, this.localWork = t.localWork, this.serviceWork = t.serviceWork, this;
+  }
+}
+class ye extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.CopyNode);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.FullWork && o === I.Local && r === this.emitEventType)
+      return this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var o;
+    const { workId: s } = e;
+    s && await ((o = this.localWork) == null ? void 0 : o.consumeFull(e));
+  }
+}
+class we extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.SetColorNode);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var a;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      textUpdateForWoker: n
+    } = e;
+    s === L && o && await ((a = this.localWork) == null ? void 0 : a.updateSelector({
+      updateSelectorOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      textUpdateForWoker: n,
+      callback: this.updateSelectorCallback
+    }));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, newServiceStore: r } = e, { willSyncService: i, isSync: c, textUpdateForWoker: n } = s, a = o.sp || [];
+    if (i)
+      for (const [h, l] of r.entries())
+        n && l.toolsType === k.Text ? a.push({
+          ...l,
+          workId: h,
+          type: p.TextUpdate,
+          dataType: I.Local,
+          willSyncService: !0
+        }) : a.push({
+          ...l,
+          workId: h,
+          type: p.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: c
+        });
+    return {
+      sp: a
+    };
+  }
+}
+class ve extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.ZIndexNode);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var n;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c
+    } = e;
+    s === L && o && await ((n = this.localWork) == null ? void 0 : n.updateSelector({
+      updateSelectorOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      callback: this.updateSelectorCallback
+    }));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, newServiceStore: r } = e, { willSyncService: i, isSync: c } = s, n = o.sp || [];
+    if (i && n)
+      for (const [a, h] of r.entries())
+        n.push({
+          ...h,
+          workId: a,
+          type: p.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: c
+        });
+    return {
+      sp: n
+    };
+  }
+}
+class Ie extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.TranslateNode);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return await this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var l, f;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      textUpdateForWoker: n,
+      emitEventType: a,
+      smoothSync: h
+    } = e;
+    s === L && o && (o.workState === g.Done && (o != null && o.translate) && (o.translate[0] || o.translate[1]) || o.workState !== g.Done ? await ((l = this.localWork) == null ? void 0 : l.updateSelector({
+      updateSelectorOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      isSync: !0,
+      textUpdateForWoker: n,
+      emitEventType: a,
+      callback: this.updateSelectorCallback,
+      smoothSync: h
+    })) : o.workState === g.Done && ((f = this.localWork) == null || f.vNodes.deleteLastTarget()));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, newServiceStore: r, workShapeNode: i, res: c, smoothSync: n } = e, { willSyncService: a, isSync: h, updateSelectorOpt: l, textUpdateForWoker: f } = s, m = l.workState, u = o.sp || [];
+    if (m === g.Start)
+      return {
+        sp: [],
+        render: []
+      };
+    const S = c == null ? void 0 : c.selectRect;
+    if (a) {
+      u.push({
+        type: p.Select,
+        selectIds: i.selectIds,
+        selectRect: S,
+        willSyncService: m === g.Done ? !0 : n,
+        isSync: !0,
+        points: m === g.Done && i.getChildrenPoints() || void 0,
+        textOpt: i.textOpt
+      });
+      const y = {
+        useAnimation: l.useAnimation || !1
+      };
+      l.uid && (y.uid = l.uid);
+      for (const [v, W] of r.entries())
+        f && W.toolsType === k.Text ? u.push({
+          ...W,
+          workId: v,
+          type: p.TextUpdate,
+          dataType: I.Local,
+          willSyncService: m === g.Done ? !0 : n,
+          updateNodeOpt: y
+        }) : (n || m === g.Done) && u.push({
+          ...W,
+          workId: v,
+          type: p.UpdateNode,
+          updateNodeOpt: y,
+          isSync: h
+        });
+    }
+    return {
+      sp: u
+    };
+  }
+}
+class ge extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.DeleteNode);
+  }
+  async consume() {
+    return !1;
+  }
+}
+class Te extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.ScaleNode);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return await this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var n;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willSyncService: r,
+      willSerializeData: i,
+      smoothSync: c
+    } = e;
+    s === L && o && await ((n = this.localWork) == null ? void 0 : n.updateSelector({
+      updateSelectorOpt: o,
+      willSyncService: r,
+      willSerializeData: i,
+      isSync: !0,
+      callback: this.updateSelectorCallback.bind(this),
+      smoothSync: c
+    }));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, workShapeNode: r, res: i, newServiceStore: c, smoothSync: n } = e, { updateSelectorOpt: a, willSyncService: h } = s, l = a.workState, f = o.sp || [], m = i == null ? void 0 : i.selectRect;
+    if (l === g.Start)
+      return {
+        sp: [],
+        render: []
+      };
+    if (h) {
+      f.push({
+        type: p.Select,
+        selectIds: r.selectIds,
+        selectRect: m,
+        willSyncService: l === g.Done ? !0 : n,
+        isSync: !0,
+        points: l === g.Done && r.getChildrenPoints() || void 0,
+        textOpt: r.textOpt
+      });
+      const u = {
+        useAnimation: a.useAnimation || !1
+      };
+      a.uid && (u.uid = a.uid);
+      for (const [S, y] of c.entries())
+        y.toolsType === k.Text ? f.push({
+          ...y,
+          workId: S,
+          type: p.TextUpdate,
+          dataType: I.Local,
+          willSyncService: l === g.Done ? !0 : n,
+          updateNodeOpt: u
+        }) : (n || l === g.Done) && f.push({
+          ...y,
+          workId: S,
+          type: p.UpdateNode,
+          updateNodeOpt: u,
+          isSync: !0
+        });
+    }
+    return {
+      sp: f
+    };
+  }
+}
+class We extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.RotateNode);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return await this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var h;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      emitEventType: n,
+      smoothSync: a
+    } = e;
+    s === L && o && await ((h = this.localWork) == null ? void 0 : h.updateSelector({
+      updateSelectorOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      emitEventType: n,
+      isSync: !0,
+      callback: this.updateSelectorCallback,
+      smoothSync: a
+    }));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, workShapeNode: r, res: i, newServiceStore: c, smoothSync: n } = e, { updateSelectorOpt: a, willSyncService: h, willSerializeData: l, isSync: f } = s, m = a.workState, u = o.sp || [], S = i == null ? void 0 : i.selectRect;
+    if (h) {
+      l && m === g.Done && u.push({
+        type: p.Select,
+        selectIds: r.selectIds,
+        selectRect: S,
+        willSyncService: m === g.Done ? !0 : n,
+        isSync: f,
+        points: r.getChildrenPoints()
+      });
+      const y = {
+        useAnimation: a.useAnimation || !1
+      };
+      if (a.uid && (y.uid = a.uid), n || m === g.Done)
+        for (const [v, W] of c.entries())
+          u.push({
+            ...W,
+            workId: v,
+            type: p.UpdateNode,
+            updateNodeOpt: y,
+            isSync: f
+          });
+    }
+    return {
+      sp: u
+    };
+  }
+}
+class Le extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.SetFontStyle);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return await this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var a;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      textUpdateForWoker: n
+    } = e;
+    s === L && o && await ((a = this.localWork) == null ? void 0 : a.updateSelector({
+      updateSelectorOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      textUpdateForWoker: n,
+      callback: this.updateSelectorCallback
+    }));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, newServiceStore: r, workShapeNode: i, res: c } = e, { willSyncService: n, isSync: a, updateSelectorOpt: h, textUpdateForWoker: l } = s, f = o.sp || [], m = c == null ? void 0 : c.selectRect;
+    if (n && f) {
+      h.fontSize && f.push({
+        type: p.Select,
+        selectIds: i.selectIds,
+        selectRect: m,
+        willSyncService: n,
+        isSync: a,
+        points: i.getChildrenPoints()
+      });
+      for (const [u, S] of r.entries())
+        l && S.toolsType === k.Text ? f.push({
+          ...S,
+          workId: u,
+          type: p.TextUpdate,
+          dataType: I.Local,
+          willSyncService: !0
+        }) : f.push({
+          ...S,
+          workId: u,
+          type: p.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: a
+        });
+    }
+    return {
+      sp: f
+    };
+  }
+}
+class be extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.SetPoint);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var a;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      textUpdateForWoker: n
+    } = e;
+    s === L && o && await ((a = this.localWork) == null ? void 0 : a.updateSelector({
+      updateSelectorOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      emitEventType: this.emitEventType,
+      willSerializeData: c,
+      isSync: !0,
+      textUpdateForWoker: n,
+      callback: this.updateSelectorCallback
+    }));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, newServiceStore: r, workShapeNode: i, res: c } = e, { willSyncService: n, isSync: a } = s, h = o.sp || [], l = c == null ? void 0 : c.selectRect;
+    if (n && h) {
+      for (const [f, m] of r.entries())
+        h.push({
+          ...m,
+          workId: f,
+          type: p.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: a
+        });
+      h.push({
+        type: p.Select,
+        selectIds: i.selectIds,
+        selectRect: l,
+        willSyncService: n,
+        isSync: a,
+        points: i.getChildrenPoints()
+      });
+    }
+    return {
+      sp: h
+    };
+  }
+}
+class Ne extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.SetLock);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var n;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c
+    } = e;
+    s === L && o && await ((n = this.localWork) == null ? void 0 : n.updateSelector({
+      updateSelectorOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      callback: this.updateSelectorCallback
+    }));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, newServiceStore: r, workShapeNode: i, res: c } = e, { willSyncService: n, isSync: a, updateSelectorOpt: h } = s, l = o.sp || [], f = c == null ? void 0 : c.selectRect;
+    if (n && l) {
+      for (const [m, u] of r.entries())
+        l.push({
+          ...u,
+          workId: m,
+          type: p.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: a
+        });
+      l.push({
+        isLocked: h.isLocked,
+        selectorColor: i.selectorColor,
+        scaleType: i.scaleType,
+        canRotate: i.canRotate,
+        type: p.Select,
+        selectIds: i.selectIds,
+        selectRect: f,
+        willSyncService: n,
+        isSync: a
+      });
+    }
+    return {
+      sp: l
+    };
+  }
+}
+class De extends R {
+  constructor() {
+    super(...arguments);
+    d(this, "emitEventType", T.SetShapeOpt);
+  }
+  async consume(e) {
+    const { msgType: s, dataType: o, emitEventType: r } = e;
+    if (s === p.UpdateNode && o === I.Local && r === this.emitEventType)
+      return this.consumeForLocalWorker(e), !0;
+  }
+  async consumeForLocalWorker(e) {
+    var n;
+    const {
+      workId: s,
+      updateNodeOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c
+    } = e;
+    s === L && o && await ((n = this.localWork) == null ? void 0 : n.updateSelector({
+      updateSelectorOpt: o,
+      willRefreshSelector: r,
+      willSyncService: i,
+      willSerializeData: c,
+      callback: this.updateSelectorCallback
+    }));
+  }
+  updateSelectorCallback(e) {
+    const { param: s, postData: o, newServiceStore: r } = e, { willSyncService: i, isSync: c } = s, n = o.sp || [];
+    if (i && n)
+      for (const [a, h] of r.entries())
+        n.push({
+          ...h,
+          workId: a,
+          type: p.UpdateNode,
+          updateNodeOpt: {
+            useAnimation: !1
+          },
+          isSync: c
+        });
+    return {
+      sp: n
+    };
+  }
+}
+class Ce {
+  constructor(t) {
+    d(this, "builders", /* @__PURE__ */ new Map());
+    this.builders = new Map(t.map((e) => [e, this.build(e)]));
+  }
+  build(t) {
+    switch (t) {
+      case T.TranslateNode:
+        return new Ie();
+      case T.ZIndexNode:
+        return new ve();
+      case T.CopyNode:
+        return new ye();
+      case T.SetColorNode:
+        return new we();
+      case T.DeleteNode:
+        return new ge();
+      case T.ScaleNode:
+        return new Te();
+      case T.RotateNode:
+        return new We();
+      case T.SetFontStyle:
+        return new Le();
+      case T.SetPoint:
+        return new be();
+      case T.SetLock:
+        return new Ne();
+      case T.SetShapeOpt:
+        return new De();
+    }
+  }
+  registerForMainThread(t) {
+    return this.builders.forEach((e) => {
+      e && e.registerMainThread(t);
+    }), this;
+  }
+  async consumeForMainThread(t) {
+    for (const e of this.builders.values())
+      if (await (e == null ? void 0 : e.consume(t)))
+        return !0;
+    return !1;
+  }
+}
+class Oe {
+  constructor(t, e) {
+    d(this, "viewId");
+    d(this, "fullLayer");
+    d(this, "topLayer");
+    d(this, "localLayer");
+    d(this, "serviceLayer");
+    d(this, "snapshotFullLayer");
+    d(this, "vNodes");
+    d(this, "master");
+    d(this, "opt");
+    d(this, "cameraOpt");
+    d(this, "scene");
+    d(this, "localWork");
+    d(this, "serviceWork");
+    d(this, "topWork");
+    d(this, "taskUpdateCameraId");
+    d(this, "debounceUpdateCameraId");
+    d(this, "debounceUpdateCache", /* @__PURE__ */ new Set());
+    d(this, "mainThreadPostId");
+    d(this, "combinePostMsg", /* @__PURE__ */ new Set());
+    d(this, "methodBuilder");
+    d(this, "cacheImages", /* @__PURE__ */ new Map());
+    d(this, "imageResolveMap", /* @__PURE__ */ new Map());
+    this.viewId = t, this.opt = e, this.scene = this.createScene({
+      ...e.canvasOpt,
+      container: e.container
+    }), this.master = e.master;
+    const s = B.bufferSize.full, o = B.bufferSize.sub;
+    this.fullLayer = this.createLayer("fullLayer", this.scene, {
+      ...e.layerOpt,
+      bufferSize: this.viewId === F ? s : o * 2
+    }), this.topLayer = this.createLayer("topLayer", this.scene, {
+      ...e.layerOpt,
+      bufferSize: (this.viewId === F, o),
+      contextType: "2d"
+    }), this.localLayer = this.createLayer("localLayer", this.scene, {
+      ...e.layerOpt,
+      bufferSize: (this.viewId === F, o),
+      contextType: "2d"
+    }), this.serviceLayer = this.createLayer("serviceLayer", this.scene, {
+      ...e.layerOpt,
+      bufferSize: (this.viewId === F, o),
+      contextType: "2d"
+    }), this.vNodes = new pe(t, this.scene);
+    const r = {
+      thread: this,
+      vNodes: this.vNodes
+    };
+    this.localWork = new ke(r), this.serviceWork = new Se(r), this.topWork = new me(r), this.vNodes.init(this.fullLayer), this.methodBuilder = new Ce([
+      T.CopyNode,
+      T.SetColorNode,
+      T.DeleteNode,
+      T.RotateNode,
+      T.ScaleNode,
+      T.TranslateNode,
+      T.ZIndexNode,
+      T.SetFontStyle,
+      T.SetPoint,
+      T.SetLock,
+      T.SetShapeOpt
+    ]).registerForMainThread(this);
+  }
+  getCachedImages(t) {
+    var e;
+    return (e = this.cacheImages.get(t)) == null ? void 0 : e.imageBitmap;
+  }
+  getCachedImagesByWorkId(t) {
+    for (const [e, s] of this.cacheImages.entries())
+      if (e === t && s.imageBitmap)
+        return s.imageBitmap;
+  }
+  deleteCachedImagesByWorkId(t) {
+    for (const [e, s] of this.cacheImages.entries())
+      s.workId === t && (s.imageBitmap.close(), this.cacheImages.delete(e));
+  }
+  clearCacheImages() {
+    this.cacheImages.forEach((t) => t.imageBitmap.close()), this.cacheImages.clear();
+  }
+  clearImageResolveMap() {
+    this.imageResolveMap.forEach(({ timer: t }) => {
+      t && clearTimeout(t);
+    }), this.imageResolveMap.clear();
+  }
+  post(t) {
+    this.combinePostMsg.add(t), this.runBatchPostData();
+  }
+  updateDpr(t) {
+    this.scene.displayRatio = t;
+  }
+  async on(t) {
+    if (!await this.methodBuilder.consumeForMainThread(t)) {
+      const {
+        msgType: e,
+        toolsType: s,
+        opt: o,
+        dataType: r,
+        workId: i,
+        workState: c,
+        imageSrc: n,
+        imageBitmap: a,
+        workIds: h,
+        isLockSentEventCursor: l
+      } = t, f = i == null ? void 0 : i.toString();
+      switch (e) {
+        case p.UpdateDpr:
+          _(t.dpr) && this.updateDpr(t.dpr);
+          break;
+        case p.AuthClear: {
+          const { clearUids: m, localUid: u } = t;
+          this.vNodes.setCanClearUids(m), this.vNodes.setLocalUid(u);
+          break;
+        }
+        case p.Destroy:
+          this.destroy();
+          break;
+        case p.Clear:
+          this.clearAll();
+          break;
+        case p.UpdateCamera:
+          await this.updateCamera(t);
+          break;
+        case p.UpdateTools:
+          if (s && o) {
+            const m = {
+              toolsType: s,
+              toolsOpt: o
+            };
+            this.topWork.canUseTopLayer(s) ? this.topWork.setToolsOpt(m) : this.localWork.setToolsOpt(m);
+          }
+          break;
+        case p.CreateWork:
+          if (f && o && s) {
+            if (this.topWork.canUseTopLayer(s)) {
+              this.topWork.getToolsOpt() || this.topWork.setToolsOpt({
+                toolsType: s,
+                toolsOpt: o
+              }), this.topWork.setWorkOptions(f, o);
+              break;
+            }
+            this.localWork.getToolsOpt() || this.localWork.setToolsOpt({
+              toolsType: s,
+              toolsOpt: o
+            }), this.localWork.setWorkOptions(f, o);
+          }
+          break;
+        case p.DrawWork:
+          c === g.Done && r === I.Local ? (this.consumeDrawAll(r, t), s === k.LaserPen && l && this.post({
+            sp: [
+              {
+                type: p.None,
+                isLockSentEventCursor: l
+              }
+            ]
+          })) : this.consumeDraw(r, t);
+          break;
+        case p.UpdateNode:
+        case p.FullWork:
+          if (s && this.topWork.canUseTopLayer(s)) {
+            this.consumeDrawAll(r, t);
+            break;
+          }
+          this.consumeFull(r, t);
+          break;
+        case p.RemoveNode:
+          await this.removeNode(t);
+          return;
+        case p.Select:
+          r === I.Service && (i === L ? this.localWork.updateFullSelectWork(t) : this.serviceWork.runSelectWork(t));
+          break;
+        case p.CursorBlur:
+          this.localWork.cursorBlur();
+          return;
+        case p.CursorHover:
+          this.localWork.cursorHover(t);
+          break;
+        case p.GetTextActive:
+          r === I.Local && this.localWork.checkTextActive(t);
+          break;
+        case p.GetImageBitMap:
+          if (n && a && i) {
+            const m = i.toString();
+            this.deleteCachedImagesByWorkId(m), this.cacheImages.set(n, {
+              imageBitmap: a,
+              workId: m
+            });
+            const u = this.imageResolveMap.get(n);
+            if (u) {
+              const { resolve: S, timer: y } = u;
+              y && clearTimeout(y), S && S(n);
+            }
+          }
+          break;
+        case p.GetVNodeInfo:
+          if (i && h) {
+            const m = h.map((u) => this.vNodes.get(u));
+            this.post({
+              sp: [
+                {
+                  type: p.GetVNodeInfo,
+                  dataType: I.Local,
+                  workId: i,
+                  vInfo: m
+                }
+              ]
+            });
+          }
+          break;
+      }
+    }
+  }
+  getIconSize(t, e, s) {
+    const o = t * s, r = e * s;
+    return o <= 50 || r <= 50 ? [50, 50] : o <= 100 || r <= 100 ? [100, 100] : o <= 200 || r <= 200 ? [200, 200] : o <= 400 || r <= 400 ? [400, 400] : o <= 800 || r <= 800 ? [800, 800] : [1600, 1600];
+  }
+  async loadImageBitMap(t) {
+    const { toolsType: e, opt: s, workId: o } = t;
+    if (e === k.Image && s && o) {
+      const r = o.toString(), { src: i, type: c, width: n, height: a, strokeColor: h } = s;
+      if (!i || !c || !n || !a)
+        return;
+      let l = i;
+      if (c === se.Iconify) {
+        const [S, y] = this.getIconSize(n, a, this.opt.displayer.dpr);
+        l = `${i}?width=${S}&height=${y}&color=${h}`;
+      }
+      if (this.cacheImages.has(l)) {
+        const S = this.getCachedImages(l);
+        if (S)
+          return S;
+      }
+      if (this.imageResolveMap.has(l)) {
+        const S = this.getCachedImagesByWorkId(r);
+        if (S)
+          return S;
+      }
+      const u = await new Promise((S) => {
+        const y = this.imageResolveMap.get(l) || {
+          resolve: void 0,
+          timer: void 0
+        };
+        y.timer && clearTimeout(y.timer), y.resolve = S, y.timer = setTimeout(() => {
+          const v = this.imageResolveMap.get(l);
+          v != null && v.resolve && v.resolve(l);
+        }, 5e3), this.imageResolveMap.set(l, y), this.opt.post({
+          sp: [
+            {
+              imageSrc: l,
+              workId: r,
+              viewId: this.viewId,
+              isgl: !!this.fullLayer.parent.gl,
+              isSubWorker: !1,
+              type: p.GetImageBitMap
+            }
+          ]
+        });
+      });
+      return this.imageResolveMap.delete(u), this.getCachedImages(l);
+    }
+  }
+  async removeNode(t) {
+    const { dataType: e, workId: s, removeIds: o } = t, r = o || [];
+    if (s && r.push(s.toString()), r.length)
+      for (const i of r) {
+        if (i === L) {
+          await this.localWork.removeSelector(t);
+          continue;
+        }
+        e === I.Local ? this.localWork.removeWork(t) : e === I.Service && this.serviceWork.removeWork(t), await this.localWork.colloctEffectSelectWork(t);
+      }
+  }
+  async consumeFull(t, e) {
+    const s = await this.localWork.colloctEffectSelectWork(e);
+    s && t === I.Local && await this.localWork.consumeFull(s), s && t === I.Service && this.serviceWork.consumeFull(s);
+  }
+  setCameraOpt(t) {
+    this.cameraOpt = t;
+    const { scale: e, centerX: s, centerY: o, width: r, height: i } = t;
+    (r !== this.scene.width || i !== this.scene.height) && this.updateScene({ width: r, height: i }), this.fullLayer.setAttribute("scale", [e, e]), this.fullLayer.setAttribute("translate", [-s, -o]), this.topLayer.setAttribute("scale", [e, e]), this.topLayer.setAttribute("translate", [-s, -o]), this.localLayer.setAttribute("scale", [e, e]), this.localLayer.setAttribute("translate", [-s, -o]), this.serviceLayer.setAttribute("scale", [e, e]), this.serviceLayer.setAttribute("translate", [-s, -o]);
+  }
+  runBatchPostData() {
+    this.mainThreadPostId || (this.mainThreadPostId = requestAnimationFrame(
+      this.combinePost.bind(this)
+    ));
+  }
+  combinePostData() {
+    var o;
+    this.mainThreadPostId = void 0;
+    const t = [];
+    let e, s;
+    for (const r of this.combinePostMsg.values()) {
+      if ((o = r.sp) != null && o.length)
+        for (const i of r.sp) {
+          let c = !1;
+          for (const n of t)
+            if (ee(i, n)) {
+              c = !0;
+              break;
+            }
+          c || t.push(i);
+        }
+      _(r.fullWorkerDrawCount) && (e = r.fullWorkerDrawCount), _(r.consumeCount) && (s = r.consumeCount);
+    }
+    return this.combinePostMsg.clear(), {
+      sp: t,
+      fullWorkerDrawCount: e,
+      consumeCount: s
+    };
+  }
+  combinePost() {
+    var s, o;
+    const t = this.combinePostData(), e = (s = t.sp) == null ? void 0 : s.filter(
+      (r) => r.type !== p.None || r.isLockSentEventCursor
+    );
+    e != null && e.length ? t.sp = e.map((r) => r.viewId ? r : { ...r, viewId: this.viewId }) : delete t.sp, t.consumeCount === void 0 && delete t.consumeCount, t.fullWorkerDrawCount === void 0 && delete t.fullWorkerDrawCount, (t != null && t.consumeCount || t != null && t.fullWorkerDrawCount || (o = t.sp) != null && o.length) && this.opt.post(t);
+  }
+  clearAll() {
+    this.fullLayer.children.length && (this.fullLayer.parent.children.forEach((t) => {
+      t.name !== "viewport" && t.remove();
+    }), U(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: p.Clear
+        }
+      ]
+    });
+  }
+  consumeDrawAll(t, e) {
+    const { toolsType: s, workId: o } = e;
+    if (o) {
+      const r = o.toString();
+      if (s && this.topWork.canUseTopLayer(s)) {
+        t === I.Local && (this.topWork.getLocalWorkShape(
+          o.toString()
+        ) || this.topWork.createLocalWork(e)), this.topWork.consumeDrawAll(e);
+        return;
+      }
+      t === I.Local && (this.localWork.getWorkShape(r) || this.localWork.createLocalWork(e), this.localWork.consumeDrawAll(e, this.serviceWork));
+    }
+  }
+  consumeDraw(t, e) {
+    const { opt: s, workId: o, toolsType: r } = e;
+    if (o && r && s) {
+      const i = o.toString();
+      if (this.topWork.canUseTopLayer(r)) {
+        t === I.Local && (this.topWork.getLocalWorkShape(i) || this.topWork.createLocalWork(e)), this.topWork.consumeDraw(e);
+        return;
+      }
+      t === I.Local ? (this.localWork.getWorkShape(i) || this.localWork.createLocalWork(e), this.localWork.consumeDraw(e, this.serviceWork)) : t === I.Service && this.serviceWork.consumeDraw(e);
+      return;
+    }
+  }
+  async updateCamera(t) {
+    var o;
+    const { cameraOpt: e, scenePath: s } = t;
+    if (e && !ee(this.cameraOpt, e)) {
+      if (this.taskUpdateCameraId && (clearTimeout(this.taskUpdateCameraId), this.taskUpdateCameraId = void 0), s) {
+        let a = !1;
+        for (const [h, l] of this.localWork.getWorkShapes().entries())
+          switch (l.toolsType) {
+            case k.Text:
+            case k.BitMapEraser:
+            case k.PencilEraser:
+            case k.Eraser:
+            case k.Selector:
+            case k.LaserPen:
+              break;
+            default:
+              h !== x && h !== L && (a = !0);
+              break;
+          }
+        if (a) {
+          this.taskUpdateCameraId = setTimeout(() => {
+            this.taskUpdateCameraId = void 0, this.updateCamera(t);
+          }, Y);
+          return;
+        }
+      }
+      const r = /* @__PURE__ */ new Map();
+      for (const [a, h] of this.vNodes.getNodesByType(k.Text).entries()) {
+        const l = h.rect;
+        r.set(a, ie(l));
+      }
+      const i = new Set(r.keys());
+      let c = !1;
+      if (this.localWork.hasSelector()) {
+        const a = (o = this.localWork.getSelector()) == null ? void 0 : o.selectIds;
+        if (a) {
+          c = !0;
+          for (const h of a)
+            i.add(h);
+        }
+      }
+      let n = !1;
+      if (this.serviceWork.selectorWorkShapes.size)
+        for (const a of this.serviceWork.selectorWorkShapes.values()) {
+          const h = a.selectIds;
+          if (h) {
+            n = !0;
+            for (const l of h)
+              i.add(l);
+          }
+        }
+      if (this.setCameraOpt(e), this.vNodes.curNodeMap.size) {
+        this.vNodes.clearTarget(), this.vNodes.updateHighLevelNodesRect(i), this.debounceUpdateCameraId && clearTimeout(this.debounceUpdateCameraId);
+        for (const [a, h] of r.entries()) {
+          const l = this.vNodes.get(a);
+          if (l) {
+            const f = h, m = l.rect, u = this.getSceneRect(), S = q(f, u), y = q(m, u);
+            let v = !1;
+            if ((S !== y || f.w !== m.w || f.h !== m.h || y === Q.intersect) && (v = !0), v) {
+              const { toolsType: W, opt: O } = l;
+              W === k.Text && O.workState === g.Done && this.debounceUpdateCache.add(a);
+            }
+          }
+        }
+        if (c && this.localWork.reRenderSelector(), n)
+          for (const [
+            a,
+            h
+          ] of this.serviceWork.selectorWorkShapes.entries())
+            this.serviceWork.runSelectWork({
+              workId: a,
+              selectIds: h.selectIds,
+              msgType: p.Select,
+              dataType: I.Service,
+              viewId: this.viewId
+            });
+        this.debounceUpdateCameraId = setTimeout(() => {
+          var h;
+          this.debounceUpdateCameraId = void 0;
+          const a = [];
+          for (const l of this.debounceUpdateCache.values()) {
+            if ((h = this.fullLayer) == null ? void 0 : h.getElementsByName(l)[0]) {
+              const m = this.vNodes.get(l);
+              if (m) {
+                const { toolsType: u, opt: S, rect: y } = m, v = this.localWork.setFullWork({
+                  toolsType: u,
+                  opt: S,
+                  workId: l
+                });
+                if (v) {
+                  const W = this.getSceneRect(), O = q(y, W);
+                  a.push(
+                    v.consumeServiceAsync({
+                      isFullWork: !0,
+                      replaceId: l,
+                      isDrawLabel: O !== Q.outside
+                    })
+                  );
+                }
+              }
+            }
+            this.debounceUpdateCache.delete(l);
+          }
+          this.vNodes.updateLowLevelNodesRect(), this.vNodes.clearHighLevelIds();
+        }, Y);
+      }
+    }
+  }
+  getSceneRect() {
+    const { width: t, height: e } = this.scene;
+    return {
+      x: 0,
+      y: 0,
+      w: Math.floor(t),
+      h: Math.floor(e)
+    };
+  }
+  createScene(t) {
+    return new oe({
+      displayRatio: this.opt.displayer.dpr,
+      depth: !1,
+      desynchronized: !0,
+      ...t,
+      autoRender: !0,
+      id: this.viewId,
+      contextType: "2d"
+    });
+  }
+  createLayer(t, e, s) {
+    const { width: o, height: r } = s, i = `canvas-${t}`, c = e.layer(i, { ...s, offscreen: !1 }), n = new re({
+      anchor: [0.5, 0.5],
+      pos: [o * 0.5, r * 0.5],
+      size: [o, r],
+      name: "viewport",
+      id: t
+    });
+    return c.append(n), n;
+  }
+  updateScene(t) {
+    this.scene.attr({ ...t });
+    const { width: e, height: s } = t;
+    this.scene.width = e, this.scene.height = s, this.updateLayer({ width: e, height: s });
+  }
+  updateLayer(t) {
+    const { width: e, height: s } = t;
+    this.fullLayer.parent.setAttribute("width", e), this.fullLayer.parent.setAttribute("height", s), this.fullLayer.setAttribute("size", [e, s]), this.fullLayer.setAttribute("pos", [e * 0.5, s * 0.5]), this.topLayer.parent.setAttribute("width", e), this.topLayer.parent.setAttribute("height", s), this.topLayer.setAttribute("size", [e, s]), this.topLayer.setAttribute("pos", [e * 0.5, s * 0.5]), this.localLayer.parent.setAttribute("width", e), this.localLayer.parent.setAttribute("height", s), this.localLayer.setAttribute("size", [e, s]), this.localLayer.setAttribute("pos", [e * 0.5, s * 0.5]), this.serviceLayer.parent.setAttribute("width", e), this.serviceLayer.parent.setAttribute("height", s), this.serviceLayer.setAttribute("size", [e, s]), this.serviceLayer.setAttribute("pos", [e * 0.5, s * 0.5]);
+  }
+  destroy() {
+    this.clearCacheImages(), this.clearImageResolveMap(), this.vNodes.clear(), this.fullLayer.remove(), A(this.fullLayer, this.fullLayer.parent), this.topLayer.remove(), A(this.topLayer, this.topLayer.parent), this.localLayer.remove(), A(this.localLayer, this.localLayer.parent), this.serviceLayer.remove(), A(this.serviceLayer, this.serviceLayer.parent), this.scene.remove(), this.localWork.destroy(), this.serviceWork.destroy(), this.topWork.destroy();
+  }
+}
+class Ee {
+  constructor(t, e) {
+    d(this, "viewId");
+    d(this, "fullLayer");
+    d(this, "master");
+    d(this, "opt");
+    d(this, "scene");
+    d(this, "mainThreadPostId");
+    d(this, "combinePostMsg", /* @__PURE__ */ new Set());
+    d(this, "workShapes", /* @__PURE__ */ new Map());
+    d(this, "cacheImages", /* @__PURE__ */ new Map());
+    d(this, "imageResolveMap", /* @__PURE__ */ new Map());
+    this.viewId = t, this.opt = e, this.scene = this.createScene({
+      ...e.canvasOpt,
+      container: e.container
+    }), this.master = e.master, this.fullLayer = this.createLayer("fullLayer", this.scene, {
+      ...e.layerOpt,
+      bufferSize: this.viewId === F ? 6e3 : 3e3,
+      contextType: "2d"
+    });
+  }
+  getCachedImages(t) {
+    var e;
+    return (e = this.cacheImages.get(t)) == null ? void 0 : e.imageBitmap;
+  }
+  getCachedImagesByWorkId(t) {
+    for (const [e, s] of this.cacheImages.entries())
+      if (e === t && s.imageBitmap)
+        return s.imageBitmap;
+  }
+  deleteCachedImagesByWorkId(t) {
+    for (const [e, s] of this.cacheImages.entries())
+      s.workId === t && (s.imageBitmap.close(), this.cacheImages.delete(e));
+  }
+  clearCacheImages() {
+    this.cacheImages.forEach((t) => t.imageBitmap.close()), this.cacheImages.clear();
+  }
+  clearImageResolveMap() {
+    this.imageResolveMap.forEach(({ timer: t }) => {
+      t && clearTimeout(t);
+    }), this.imageResolveMap.clear();
+  }
+  post(t) {
+    this.combinePostMsg.add(t), this.runBatchPostData();
+  }
+  async on(t) {
+    const { msgType: e, imageSrc: s, imageBitmap: o, workId: r } = t;
+    switch (e) {
+      case p.Snapshot:
+        await this.getSnapshot(t), this.destroy();
+        return;
+      case p.BoundingBox:
+        await this.getBoundingRect(t), this.destroy();
+        return;
+      case p.GetImageBitMap:
+        if (s && o && r) {
+          const i = r.toString();
+          this.deleteCachedImagesByWorkId(i), this.cacheImages.set(s, {
+            imageBitmap: o,
+            workId: i
+          });
+          const c = this.imageResolveMap.get(s);
+          if (c) {
+            const { resolve: n, timer: a } = c;
+            a && clearTimeout(a), n && n(s);
+          }
+        }
+        break;
+    }
+  }
+  getIconSize(t, e, s) {
+    const o = t * s, r = e * s;
+    return o <= 50 || r <= 50 ? [50, 50] : o <= 100 || r <= 100 ? [100, 100] : o <= 200 || r <= 200 ? [200, 200] : o <= 400 || r <= 400 ? [400, 400] : o <= 800 || r <= 800 ? [800, 800] : [1600, 1600];
+  }
+  async loadImageBitMap(t) {
+    const { toolsType: e, opt: s, workId: o } = t;
+    if (e === k.Image && s && o) {
+      const r = o.toString(), { src: i, type: c, width: n, height: a, strokeColor: h } = s;
+      if (!i || !c || !n || !a)
+        return;
+      let l = i;
+      if (c === se.Iconify) {
+        const [S, y] = this.getIconSize(n, a, this.opt.displayer.dpr);
+        l = `${i}?width=${S}&height=${y}&color=${h}`;
+      }
+      if (this.cacheImages.has(l)) {
+        const S = this.getCachedImages(l);
+        if (S)
+          return S;
+      }
+      if (this.imageResolveMap.has(l)) {
+        const S = this.getCachedImagesByWorkId(r);
+        if (S)
+          return S;
+      }
+      const u = await new Promise((S) => {
+        const y = this.imageResolveMap.get(l) || {
+          resolve: void 0,
+          timer: void 0
+        };
+        y.timer && clearTimeout(y.timer), y.resolve = S, y.timer = setTimeout(() => {
+          const v = this.imageResolveMap.get(l);
+          v != null && v.resolve && v.resolve(l);
+        }, 5e3), this.imageResolveMap.set(l, y), this.opt.post({
+          sp: [
+            {
+              imageSrc: l,
+              workId: r,
+              viewId: this.viewId,
+              isgl: !!this.fullLayer.parent.gl,
+              isSubWorker: !0,
+              type: p.GetImageBitMap
+            }
+          ]
+        });
+      });
+      return this.imageResolveMap.delete(u), this.getCachedImages(l);
+    }
+  }
+  createWorkShapeNode(t) {
+    return H({
+      ...t,
+      fullLayer: this.fullLayer,
+      drawLayer: void 0
+    });
+  }
+  setFullWork(t) {
+    const { workId: e, opt: s, toolsType: o } = t;
+    if (e && s && o) {
+      const r = e.toString();
+      let i;
+      return e && this.workShapes.has(r) ? (i = this.workShapes.get(r), i == null || i.setWorkOptions(s)) : i = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: o,
+        workId: r
+      }), i ? (this.workShapes.set(r, i), i) : void 0;
+    }
+  }
+  async runFullWork(t) {
+    var o;
+    const e = this.setFullWork(t), s = t.ops && P(t.ops);
+    if (e) {
+      let r, i;
+      const c = (o = e.getWorkId()) == null ? void 0 : o.toString();
+      return e.toolsType === k.Image ? r = await e.consumeServiceAsync({
+        isFullWork: !0,
+        worker: this
+      }) : e.toolsType === k.Text ? r = await e.consumeServiceAsync({
+        isFullWork: !0,
+        replaceId: c,
+        isDrawLabel: !0
+      }) : (r = e.consumeService({
+        op: s,
+        isFullWork: !0,
+        replaceId: c
+      }), i = (t == null ? void 0 : t.updateNodeOpt) && e.updataOptService(t.updateNodeOpt)), G(r, i);
+    }
+  }
+  async getSnapshot(t) {
+    const { scenePath: e, scenes: s, cameraOpt: o, w: r, h: i } = t;
+    if (e && s && o) {
+      this.setCameraOpt(o);
+      let c;
+      for (const [a, h] of Object.entries(s))
+        if (h != null && h.type)
+          switch (h == null ? void 0 : h.type) {
+            case p.UpdateNode:
+            case p.FullWork: {
+              const { opt: l } = h, f = {
+                ...h,
+                opt: l,
+                workId: a,
+                msgType: p.FullWork,
+                dataType: I.Service,
+                viewId: this.viewId
+              }, m = await this.runFullWork(f);
+              c = G(c, m);
+              break;
+            }
+          }
+      let n;
+      r && i && (n = {
+        resizeWidth: r,
+        resizeHeight: i
+      }), await this.getSnapshotRender({ scenePath: e, options: n });
+    }
+  }
+  getSceneRect() {
+    const { width: t, height: e } = this.scene;
+    return {
+      x: 0,
+      y: 0,
+      w: Math.floor(t),
+      h: Math.floor(e)
+    };
+  }
+  getRectImageBitmap(t, e) {
+    const s = Math.floor(t.x * this.opt.displayer.dpr), o = Math.floor(t.y * this.opt.displayer.dpr), r = t.w > 0 && Math.floor(t.w * this.opt.displayer.dpr || 1) || 1, i = t.h > 0 && Math.floor(t.h * this.opt.displayer.dpr || 1) || 1;
+    return createImageBitmap(
+      this.fullLayer.parent.canvas,
+      s,
+      o,
+      r,
+      i,
+      e
+    );
+  }
+  async getSnapshotRender(t) {
+    var r;
+    const { scenePath: e, options: s } = t;
+    ((r = this.fullLayer) == null ? void 0 : r.parent).render();
+    const o = await this.getRectImageBitmap(
+      this.getSceneRect(),
+      s
+    );
+    o && (this.post({
+      sp: [
+        {
+          type: p.Snapshot,
+          scenePath: e,
+          imageBitmap: o,
+          viewId: this.viewId
+        }
+      ]
+    }), this.fullLayer && U(this.fullLayer, this.fullLayer.parent));
+  }
+  async getBoundingRect(t) {
+    const { scenePath: e, scenes: s, cameraOpt: o } = t;
+    if (e && s && o) {
+      this.setCameraOpt(o);
+      let r;
+      for (const [i, c] of Object.entries(s))
+        if (c != null && c.type)
+          switch (c == null ? void 0 : c.type) {
+            case p.UpdateNode:
+            case p.FullWork: {
+              const n = await this.runFullWork({
+                ...c,
+                workId: i,
+                msgType: p.FullWork,
+                dataType: I.Service,
+                viewId: this.viewId
+              });
+              r = G(r, n);
+              break;
+            }
+          }
+      r && this.post({
+        sp: [
+          {
+            type: p.BoundingBox,
+            scenePath: e,
+            rect: r
+          }
+        ]
+      });
+    }
+  }
+  setCameraOpt(t) {
+    const { scale: e, centerX: s, centerY: o, width: r, height: i } = t;
+    this.updateScene({ width: r, height: i }), this.fullLayer.setAttribute("scale", [e, e]), this.fullLayer.setAttribute("translate", [-s, -o]);
+  }
+  runBatchPostData() {
+    this.mainThreadPostId || (this.mainThreadPostId = requestAnimationFrame(
+      this.combinePost.bind(this)
+    ));
+  }
+  combinePostData() {
+    var e;
+    this.mainThreadPostId = void 0;
+    const t = [];
+    for (const s of this.combinePostMsg.values())
+      if ((e = s.sp) != null && e.length)
+        for (const o of s.sp) {
+          let r = !1;
+          for (const i of t)
+            if (de(o, i)) {
+              r = !0;
+              break;
+            }
+          r || t.push(o);
+        }
+    return this.combinePostMsg.clear(), {
+      sp: t
+    };
+  }
+  combinePost() {
+    var s, o;
+    const t = this.combinePostData(), e = (s = t.sp) == null ? void 0 : s.filter(
+      (r) => r.type !== p.None || r.isLockSentEventCursor
+    );
+    e != null && e.length ? t.sp = e.map((r) => r.viewId ? r : { ...r, viewId: this.viewId }) : delete t.sp, (o = t.sp) != null && o.length && this.opt.post(t);
+  }
+  createScene(t) {
+    return new oe({
+      displayRatio: this.opt.displayer.dpr,
+      depth: !1,
+      desynchronized: !0,
+      ...t,
+      autoRender: !1,
+      contextType: "2d"
+    });
+  }
+  createLayer(t, e, s) {
+    const { width: o, height: r } = s, i = `canvas-${t}`, c = e.layer(i, s), n = new re({
+      anchor: [0.5, 0.5],
+      pos: [o * 0.5, r * 0.5],
+      size: [o, r],
+      name: "viewport",
+      id: t
+    });
+    return c.append(n), n;
+  }
+  updateScene(t) {
+    this.scene.attr({ ...t });
+    const { width: e, height: s } = t;
+    this.scene.width = e, this.scene.height = s, this.updateLayer({ width: e, height: s });
+  }
+  updateLayer(t) {
+    const { width: e, height: s } = t;
+    this.fullLayer.parent.setAttribute("width", e), this.fullLayer.parent.setAttribute("height", s), this.fullLayer.setAttribute("size", [e, s]), this.fullLayer.setAttribute("pos", [e * 0.5, s * 0.5]);
+  }
+  destroy() {
+    this.clearCacheImages(), this.clearImageResolveMap(), this.fullLayer.remove(), A(this.fullLayer, this.fullLayer.parent), this.scene.remove();
+  }
+}
+class He {
+  constructor(t) {
+    d(this, "mainThreadMap", /* @__PURE__ */ new Map());
+    d(this, "snapshotThread");
+    d(this, "master");
+    this.master = t;
+  }
+  post(t) {
+    const { fullWorkerDrawCount: e, sp: s, workerTasksqueueCount: o, consumeCount: r } = t;
+    this.master.isBusy && V(o) && this.master.setWorkerTasksqueueCount(o), V(e) && this.master.setMaxDrawCount(e), V(r) && this.master.setConsumeCount(r), s && this.master.collectorSyncData(s);
+  }
+  destroy() {
+    this.mainThreadMap.clear();
+  }
+  createMainThread(t, e) {
+    return new Oe(t, e);
+  }
+  createSnapshotThread(t, e) {
+    return new Ee(t, e);
+  }
+  async consume(t) {
+    var e, s, o, r;
+    for (const i of t.values()) {
+      const {
+        msgType: c,
+        viewId: n,
+        tasksqueue: a,
+        mainTasksqueueCount: h,
+        layerOpt: l,
+        offscreenCanvasOpt: f,
+        cameraOpt: m,
+        isSubWorker: u
+      } = i;
+      if (c === p.Console) {
+        console.log(this);
+        continue;
+      }
+      if (c === p.Init) {
+        const y = (e = this.master.control.viewContainerManager.getView(n)) == null ? void 0 : e.displayer, v = y == null ? void 0 : y.canvasContainerRef.current;
+        if (y && v && l && f) {
+          const W = this.createMainThread(n, {
+            displayer: y,
+            container: v,
+            layerOpt: l,
+            master: this.master,
+            canvasOpt: f,
+            post: this.post.bind(this)
+          });
+          this.mainThreadMap.set(n, W), W && m && W.setCameraOpt(m);
+        }
+        continue;
+      }
+      if ((c === p.Snapshot || c === p.BoundingBox) && n === ((s = this.master.control.viewContainerManager.mainView) == null ? void 0 : s.id)) {
+        const y = (o = this.master.control.viewContainerManager.getView(n)) == null ? void 0 : o.displayer, v = (r = y.snapshotContainerRef) == null ? void 0 : r.current;
+        if (y && v && m) {
+          v.style.width = `${m.width}px`, v.style.height = `${m.height}px`;
+          const W = {
+            ...J.defaultLayerOpt,
+            offscreen: !1,
+            width: m.width,
+            height: m.height
+          }, O = {
+            ...J.defaultScreenCanvasOpt,
+            width: m.width,
+            height: m.height
+          };
+          this.snapshotThread = this.createSnapshotThread(n, {
+            displayer: y,
+            container: v,
+            layerOpt: W,
+            master: this.master,
+            canvasOpt: O,
+            post: this.post.bind(this)
+          }), this.snapshotThread.on(i).then(() => {
+            this.snapshotThread = void 0, v.innerHTML = "", v.style.width = "", v.style.height = "";
+          });
+          continue;
+        }
+      }
+      if (c === p.GetImageBitMap && u && this.snapshotThread) {
+        this.snapshotThread.on(i);
+        continue;
+      }
+      if (c === p.TasksQueue && (a != null && a.size)) {
+        for (const [y, v] of this.mainThreadMap.entries()) {
+          const W = a.get(y);
+          W && (await v.on(W), h && this.post({ workerTasksqueueCount: h }));
+        }
+        continue;
+      }
+      if (n === ue) {
+        for (const y of this.mainThreadMap.values())
+          y.on(i), c === p.Destroy && this.mainThreadMap.delete(n);
+        continue;
+      }
+      const S = this.mainThreadMap.get(n);
+      S && (S.on(i), c === p.Destroy && this.mainThreadMap.delete(n));
+    }
+  }
+}
+export {
+  He as MainThreadManagerImpl
+};