@netless/appliance-plugin 1.1.36 → 1.1.38-beta.0

package/dist/index-RGIk2cUF.mjs

@@ -0,0 +1,771 @@
+var B = Object.defineProperty;
+var x = (o, e, t) => e in o ? B(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var h = (o, e, t) => x(o, typeof e != "symbol" ? e + "" : e, t);
+import { E as I, a as d, b as L, c as y, d as N, V as b, S as A } from "./index-C2MVZqzb.mjs";
+import { isEqual as T, isString as V, clone as D, throttle as H } from "lodash";
+import "white-web-sdk";
+import "spritejs";
+import "lz-string";
+import "clipper-lib";
+import "lineclip";
+import "xss";
+import "react-dom";
+import "react";
+import { g as C } from "./markmap-runtime-Cg3OxuZ2.mjs";
+import { O as q } from "./ObserverMap-BudneEfB.mjs";
+class R {
+  constructor() {
+    h(this, "threadEngine");
+  }
+  registerBackgroundThread(e) {
+    return this.threadEngine = e, this;
+  }
+}
+class U extends R {
+  constructor() {
+    super(...arguments);
+    h(this, "emitEventType", I.CopyNode);
+  }
+  async consume(t) {
+    const { msgType: s, dataType: a, emitEventType: r } = t;
+    if (s === d.FullWork && a === L.Local && r === this.emitEventType)
+      return this.consumeForLocalWorker(t), !0;
+  }
+  async consumeForLocalWorker(t) {
+    var a;
+    const { workId: s } = t;
+    s && await ((a = this.threadEngine) == null ? void 0 : a.consumeFull(t));
+  }
+}
+class _ {
+  constructor(e) {
+    h(this, "builders", /* @__PURE__ */ new Map());
+    this.builders = new Map(e.map((t) => [t, this.build(t)]));
+  }
+  build(e) {
+    switch (e) {
+      case I.CopyNode:
+        return new U();
+    }
+  }
+  registerForBackgroundThread(e) {
+    return this.builders.forEach((t) => {
+      t && t.registerBackgroundThread(e);
+    }), this;
+  }
+  async consumeForBackgroundThread(e) {
+    for (const t of this.builders.values())
+      if (await (t == null ? void 0 : t.consume(e)))
+        return !0;
+    return !1;
+  }
+}
+async function $(o) {
+  const e = o.querySelectorAll("img"), t = Array.from(e).map((r) => {
+    if (!r.crossOrigin && r.src && !r.src.startsWith("data:") && (r.crossOrigin = "anonymous", r.complete)) {
+      const i = r.src;
+      r.src = "", r.src = i;
+    }
+    return r.complete && r.crossOrigin ? Promise.resolve() : new Promise((i) => {
+      r.onload = () => {
+        i(void 0);
+      }, r.onerror = () => {
+        i(void 0);
+      };
+    });
+  });
+  return o.querySelectorAll("svg").forEach((r) => {
+    r.querySelectorAll("image").forEach((n) => {
+      n.href && !n.href.baseVal.startsWith("data:") && (n.getAttribute("crossorigin") || n.setAttribute("crossorigin", "anonymous"), t.push(
+        new Promise((c) => {
+          const l = new Image();
+          l.crossOrigin = "anonymous", l.onload = () => {
+            c(void 0);
+          }, l.onerror = () => {
+            c(void 0);
+          }, l.src = n.href.baseVal;
+        })
+      ));
+    });
+  }), await Promise.all(t);
+}
+async function z(o) {
+  const s = Date.now();
+  let a = !1;
+  for (; Date.now() - s < 5e3; ) {
+    const r = o.querySelectorAll("path");
+    if (r.length > 0 && (a = Array.from(r).some((i) => {
+      const n = i.getAttribute("d") || "";
+      return n !== "M0,0C0,0,0,0,0,0" && n.length > 10;
+    }), a))
+      break;
+    await new Promise((i) => setTimeout(i, 50));
+  }
+}
+async function G(o) {
+  const e = o.querySelectorAll("svg");
+  if (!e.length)
+    return;
+  const t = [];
+  for (let s = 0; s < e.length; s++) {
+    const a = e[s];
+    t.push(z(a));
+  }
+  await Promise.all(t);
+}
+async function W(o) {
+  if (o.querySelectorAll("svg[data-type='mermaid']").length > 0) {
+    const s = Date.now();
+    let a = !1;
+    for (; Date.now() - s < 5e3 && !a; ) {
+      const r = o.querySelectorAll("foreignObject");
+      if (r.length > 0) {
+        let i = !0;
+        for (const n of Array.from(r)) {
+          const c = parseFloat(n.getAttribute("width") || "0"), l = parseFloat(n.getAttribute("height") || "0");
+          if (n.querySelector(".mermaid-container") && (c < 50 || l < 50)) {
+            i = !1;
+            break;
+          }
+        }
+        if (i) {
+          a = !0;
+          break;
+        }
+      } else
+        a = !0;
+      await new Promise((i) => setTimeout(i, 50));
+    }
+  }
+}
+async function X(o, e = {}) {
+  const { width: t = o.offsetWidth, height: s = o.offsetHeight } = e, a = o.offsetWidth || t, r = o.offsetHeight || s;
+  try {
+    const { loadSvgToImageLib: i, getSvgToImageLib: n } = await import("./svgToImageLoader-DZz5bAo4.mjs");
+    let c = n();
+    if (!c)
+      try {
+        c = await i();
+      } catch (w) {
+        return console.error("[loadSvgToImageLib] error: ", w), null;
+      }
+    const l = o.style.width, m = o.style.height, k = o.style.display;
+    o.style.width || (o.style.width = `${a}px`), o.style.height || (o.style.height = `${r}px`), (!o.style.display || o.style.display === "none") && (o.style.display = "block");
+    try {
+      await new Promise((p) => {
+        requestAnimationFrame(() => {
+          requestAnimationFrame(() => {
+            p();
+          });
+        });
+      });
+      const w = await c.toPng(o, {
+        width: a,
+        height: r,
+        quality: 1
+      });
+      return o.style.width = l, o.style.height = m, o.style.display = k, new Promise((p) => {
+        const u = new Image();
+        u.crossOrigin = "anonymous", u.onload = () => {
+          p(u);
+        }, u.onerror = () => {
+          p(null);
+        }, u.src = w;
+      });
+    } catch (w) {
+      return o.style.width = l, o.style.height = m, o.style.display = k, console.error("[divToImageElement] error: ", w), null;
+    }
+  } catch (i) {
+    return console.error("[divToImageElement] error: ", i), null;
+  }
+}
+class Y {
+  constructor(e) {
+    h(this, "toolsType", y.BackgroundSVG);
+    h(this, "vNodes");
+    h(this, "workOptions");
+    h(this, "workId");
+    h(this, "markmapInstance", null);
+    h(this, "isDestroyed", !1);
+    h(this, "element");
+    h(this, "manager");
+    const { vNodes: t, workId: s, toolsOpt: a, manager: r } = e;
+    this.workId = s, this.vNodes = t, this.workOptions = a, this.manager = r, this.element = this.createElement(), this.manager.fullLayer.appendChild(this.element), this.vNodes.setInfo(this.workId, {
+      workShape: this
+    });
+  }
+  get fullLayer() {
+    return this.manager.fullLayer;
+  }
+  get collector() {
+    return this.manager.master.control.collector;
+  }
+  get scenePath() {
+    return this.manager.master.control.viewContainerManager.getCurScenePath(
+      this.manager.viewId
+    );
+  }
+  async init() {
+    await this.render();
+  }
+  createElement() {
+    const { type: e } = this.workOptions;
+    let t;
+    return e === N.markmap ? (t = document.createElementNS("http://www.w3.org/2000/svg", "svg"), t.classList.add("svg")) : (t = document.createElement("img"), t.classList.add("img")), t.id = this.workId, t.setAttribute("data-id", this.workId), t;
+  }
+  async render(e) {
+    this.isDestroyed || !this.element || !this.element.parentNode || (this.updateElementPosition(e), await this.updateSvg(e));
+  }
+  isSameSize(e) {
+    const { width: t, height: s } = e, { width: a, height: r } = this.workOptions, i = t * this.manager.camera.scale, n = s * this.manager.camera.scale, c = a * this.manager.camera.scale, l = r * this.manager.camera.scale;
+    return i === c && n === l;
+  }
+  isSamePosition(e) {
+    const { centerX: t, centerY: s } = e, { centerX: a, centerY: r } = this.workOptions, i = this.manager.getPagePoint(a, r), n = this.manager.getPagePoint(t, s);
+    return T(n, i);
+  }
+  isSameZIndex(e) {
+    const { zIndex: t } = e, { zIndex: s } = this.workOptions;
+    return t === s;
+  }
+  isSameState(e) {
+    const { state: t } = e, { state: s } = this.workOptions;
+    return T(t, s);
+  }
+  isSameData(e) {
+    const { data: t } = e, { data: s } = this.workOptions;
+    return T(t, s);
+  }
+  updateElementPosition(e) {
+    if (this.isDestroyed || !this.element || !this.fullLayer)
+      return;
+    const { centerX: t, centerY: s, width: a, height: r, zIndex: i } = this.workOptions, n = this.manager.getPagePoint(t, s), c = a * this.manager.camera.scale, l = r * this.manager.camera.scale;
+    (!e || e && !this.isSameSize(e)) && (this.element.setAttribute("width", `${c}`), this.element.setAttribute("height", `${l}`), this.element.style.width = `${c}px`, this.element.style.height = `${l}px`), (!e || e && !this.isSamePosition(e)) && (this.element.style.left = `${n.x}px`, this.element.style.top = `${n.y}px`), (!e || e && !this.isSameZIndex(e)) && (this.element.style.zIndex = (i || 0).toString());
+  }
+  async updateSvg(e) {
+    const { type: t, state: s } = this.workOptions;
+    if (t === N.markmap) {
+      const a = C(), { data: r } = this.workOptions;
+      if (this.markmapInstance || (this.markmapInstance = a.createMarkmap(
+        this.element,
+        this.manager.markmapOptions
+      ), this.markmapInstance.handleClick = async (c, l) => {
+        var w, p, u;
+        (w = this.markmapInstance) == null || w.toggleNode(l);
+        const m = this.serializeData((p = this.markmapInstance) == null ? void 0 : p.state.data);
+        this.setWorkOptions(
+          {
+            ...this.workOptions,
+            state: m
+          },
+          !1
+        ), a.checkNodeHasMermaid(l) && await a.renderMermaidAfterDOMUpdate(
+          this.element,
+          this.workId
+        ), this.scenePath && this.collector && ((u = this.collector) == null || u.dispatch({
+          type: d.UpdateNode,
+          workId: this.workId,
+          opt: this.workOptions,
+          isSync: !0,
+          viewId: this.manager.viewId,
+          scenePath: this.scenePath
+        }));
+      }), e && this.isSameState(e) && this.isSameSize(e) && this.isSameData(e))
+        return;
+      const i = a.transform(this.workId, r);
+      let { root: n } = i;
+      r && a.hasMermaidCodeBlock(r) && (n = a.injectMermaidHtml(n, r, this.workId));
+      try {
+        s && Array.isArray(s) && this.transformState(s, n), await this.markmapInstance.setData(n), !this.isDestroyed && this.element && this.fullLayer && this.markmapInstance && (window.markmapInstance = this.markmapInstance, r && a.hasMermaidCodeBlock(r) && await a.renderMermaidAfterDOMUpdate(
+          this.element,
+          this.workId
+        ), await this.fit(
+          !e || e && !this.isSameData(e)
+        ));
+      } catch (c) {
+        console.error("[updateSvg] error: ", c);
+      }
+    } else {
+      const { src: a, crossOrigin: r } = this.workOptions;
+      this.element.src = a, this.element.crossOrigin = V(r) ? r : "anonymous";
+      try {
+        await new Promise((i, n) => {
+          this.element.onload = () => {
+            i();
+          }, this.element.onerror = function() {
+            n();
+          };
+        });
+      } catch (i) {
+        console.error("[updateSvg] error: ", i);
+      }
+    }
+  }
+  async fit(e = !0) {
+    var t;
+    if (!this.isDestroyed && this.element && this.fullLayer && this.markmapInstance) {
+      const s = C();
+      e && this.element && await s.waitForImagesInForeignObjects(
+        this.element
+      ), await ((t = this.markmapInstance) == null ? void 0 : t.fit()), this.element && s.isSafari() && s.hasMermaidSvg(this.element) && (await W(this.element), await s.transformMermaidSvgToMarkmapSvg(
+        this.element
+      ));
+    }
+  }
+  serializeData(e) {
+    var a;
+    const t = [e], s = [];
+    for (; t.length > 0; ) {
+      const r = t.pop();
+      r && (r != null && r.children && t.push(...r.children), s.push(((a = r == null ? void 0 : r.payload) == null ? void 0 : a.fold) || 0));
+    }
+    return s;
+  }
+  transformState(e, t) {
+    const s = [t];
+    for (; s.length > 0; ) {
+      const a = s.pop();
+      a && (a != null && a.children && s.push(...a.children), a.payload ? a.payload.fold = e.shift() : e.shift());
+    }
+  }
+  async updateCamera() {
+    this.updateElementPosition(), await this.fit(!1);
+  }
+  async setWorkOptions(e, t = !0) {
+    if (!T(this.workOptions, e)) {
+      const s = D(this.workOptions);
+      this.workOptions = e, t && await this.render(s);
+    }
+  }
+  destroy() {
+    this.isDestroyed = !0, this.element.remove();
+  }
+  getRectFromLayer() {
+    const e = this.element.getBoundingClientRect();
+    return {
+      x: e.x,
+      y: e.y,
+      w: e.width,
+      h: e.height
+    };
+  }
+}
+function F(o) {
+  const { toolsType: e, ...t } = o;
+  switch (e) {
+    case y.BackgroundSVG:
+      return new Y(t);
+    default:
+      return;
+  }
+}
+class P {
+  constructor(e) {
+    h(this, "viewId");
+    h(this, "fullLayer");
+    h(this, "curNodeMap");
+    this.viewId = e, this.curNodeMap = new q();
+  }
+  init(e) {
+    this.fullLayer = e;
+  }
+  get(e) {
+    return this.curNodeMap.get(e);
+  }
+  setInfo(e, t) {
+    const s = this.curNodeMap.get(
+      e
+    ) || {
+      name: e,
+      workShape: t.workShape
+    };
+    t.workShape && (s.workShape = t.workShape), this.curNodeMap.set(e, s);
+  }
+  getNodeRectFormShape(e) {
+    const t = this.curNodeMap.get(e);
+    if (t && t.workShape)
+      return t.workShape.getRectFromLayer();
+  }
+  delete(e) {
+    const t = this.curNodeMap.get(e);
+    t && t.workShape.destroy(), this.curNodeMap.delete(e);
+  }
+  clear() {
+    for (const e of this.curNodeMap.values())
+      e.workShape.destroy();
+    this.curNodeMap.clear();
+  }
+}
+class j {
+  constructor(e, t) {
+    h(this, "opt");
+    h(this, "viewId");
+    h(this, "fullLayer");
+    h(this, "vNodes");
+    h(this, "master");
+    h(this, "cameraOpt");
+    h(this, "methodBuilder");
+    h(this, "updateCamera", H(async (e) => {
+      const { cameraOpt: t } = e;
+      t && !T(this.cameraOpt, t) && await this.setCameraOpt(t);
+    }, 100));
+    this.viewId = e, this.opt = t, this.master = t.master, this.fullLayer = t.container, this.methodBuilder = new _([
+      I.CopyNode
+    ]).registerForBackgroundThread(this), this.vNodes = new P(e), this.vNodes.init(this.fullLayer);
+  }
+  get camera() {
+    return this.cameraOpt || {
+      scale: 1,
+      centerX: 0,
+      centerY: 0,
+      width: 0,
+      height: 0
+    };
+  }
+  get view() {
+    var e;
+    return (e = this.master.control.viewContainerManager.getView(this.viewId)) == null ? void 0 : e.viewData;
+  }
+  get markmapOptions() {
+    return this.master.control.pluginOptions.extras.markmap.options;
+  }
+  getPagePoint(e, t) {
+    const { scale: s, centerX: a, centerY: r, width: i, height: n } = this.camera;
+    return {
+      x: (e - a) * s + i / 2,
+      y: (t - r) * s + n / 2
+    };
+  }
+  async setCameraOpt(e) {
+    this.cameraOpt = e;
+    for (const t of this.vNodes.curNodeMap.values()) {
+      const { workShape: s } = t;
+      s && await s.updateCamera();
+    }
+  }
+  clearAll() {
+    this.vNodes.clear();
+  }
+  canUseFullLayer(e) {
+    return e === y.BackgroundSVG;
+  }
+  async consumeFull(e) {
+    const { toolsType: t, opt: s, workId: a } = e;
+    if (a != null && a.toString() && t && this.canUseFullLayer(t))
+      switch (t) {
+        case y.BackgroundSVG:
+          await this.setFullWork({
+            toolsType: t,
+            opt: s,
+            workId: a
+          });
+          break;
+      }
+  }
+  async setFullWork(e) {
+    const { workId: t, opt: s, toolsType: a } = e;
+    if (t && s && a) {
+      const r = t.toString();
+      let i;
+      const n = this.vNodes.get(r);
+      return !n || !n.workShape ? (i = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: y.BackgroundSVG,
+        workId: r
+      }), i && await i.init()) : (i = n.workShape, await i.setWorkOptions(s)), i;
+    }
+  }
+  createWorkShapeNode(e) {
+    return F({
+      ...e,
+      vNodes: this.vNodes,
+      manager: this
+    });
+  }
+  removeWork(e) {
+    const { workId: t } = e, s = t == null ? void 0 : t.toString();
+    s && this.removeNode(s);
+  }
+  removeNode(e) {
+    this.vNodes.delete(e);
+  }
+  async on(e) {
+    if (!await this.methodBuilder.consumeForBackgroundThread(e)) {
+      const { msgType: t, toolsType: s } = e;
+      switch (t) {
+        case d.Destroy: {
+          this.destroy();
+          break;
+        }
+        case d.Clear: {
+          this.clearAll();
+          break;
+        }
+        case d.UpdateCamera: {
+          this.updateCamera(e);
+          break;
+        }
+        case d.UpdateTools: {
+          this.toggleFullLayer(s === y.Clicker);
+          break;
+        }
+        case d.BackgroundSVGUpdate:
+        case d.UpdateNode:
+        case d.FullWork: {
+          s && this.canUseFullLayer(s) && await this.consumeFull(e);
+          break;
+        }
+        case d.BackgroundSVGDelete: {
+          this.removeWork(e);
+          break;
+        }
+      }
+    }
+  }
+  toggleFullLayer(e) {
+    this.fullLayer.classList.toggle(
+      "appliance-plugin-background-svg-active",
+      e
+    );
+  }
+  destroy() {
+    this.vNodes.clear();
+  }
+}
+class Z {
+  constructor(e, t) {
+    h(this, "viewId");
+    h(this, "fullLayer");
+    h(this, "master");
+    h(this, "vNodes");
+    h(this, "cameraOpt");
+    h(this, "opt");
+    h(this, "workShapes", /* @__PURE__ */ new Map());
+    this.viewId = e, this.opt = t, this.master = t.master, this.fullLayer = t.container, this.vNodes = new P(e), this.vNodes.init(this.fullLayer);
+  }
+  get camera() {
+    return this.cameraOpt || {
+      scale: 1,
+      centerX: 0,
+      centerY: 0,
+      width: 0,
+      height: 0
+    };
+  }
+  get view() {
+    var e;
+    return (e = this.master.control.viewContainerManager.getView(this.viewId)) == null ? void 0 : e.viewData;
+  }
+  get markmapOptions() {
+    return this.master.control.pluginOptions.extras.markmap.options;
+  }
+  createOffscreenCanvas(e) {
+    const { width: t, height: s } = e.canvasOpt, a = new OffscreenCanvas(
+      e.canvasOpt.width,
+      e.canvasOpt.height
+    );
+    a.width = t, a.height = s;
+  }
+  async setCameraOpt(e) {
+    this.cameraOpt = e;
+    for (const t of this.vNodes.curNodeMap.values()) {
+      const { workShape: s } = t;
+      s && await s.updateCamera();
+    }
+  }
+  getPagePoint(e, t) {
+    const { scale: s, centerX: a, centerY: r, width: i, height: n } = this.camera;
+    return {
+      x: (e - a) * s + i / 2,
+      y: (t - r) * s + n / 2
+    };
+  }
+  async getSnapshot(e) {
+    const { scenePath: t, scenes: s, cameraOpt: a } = e;
+    if (t && s && a) {
+      await this.setCameraOpt(a);
+      for (const [r, i] of Object.entries(s))
+        if (i != null && i.type && (i == null ? void 0 : i.toolsType) === y.BackgroundSVG)
+          switch (i == null ? void 0 : i.type) {
+            case d.UpdateNode:
+            case d.FullWork: {
+              const { opt: n } = i, c = {
+                ...i,
+                opt: n,
+                workId: r,
+                msgType: d.FullWork,
+                dataType: L.Service,
+                viewId: this.viewId
+              };
+              await this.runFullWork(c);
+              break;
+            }
+          }
+      try {
+        if (t) {
+          await W(this.fullLayer), await $(this.fullLayer), await G(this.fullLayer);
+          const r = await X(this.fullLayer);
+          r && this.opt.post({
+            sp: [
+              {
+                type: d.Snapshot,
+                scenePath: t,
+                imageElement: r,
+                viewId: this.viewId,
+                index: 1
+              }
+            ]
+          });
+        }
+      } catch (r) {
+        const i = r && r instanceof Error ? r.message : r == null ? void 0 : r.toString();
+        this.opt.post({
+          sp: [
+            {
+              type: d.ReportError,
+              reportString: `[SnapshotThreadImpl] getSnapshotRender error: ${i}`
+            }
+          ]
+        });
+      }
+    }
+  }
+  createWorkShapeNode(e) {
+    return F({
+      ...e,
+      vNodes: this.vNodes,
+      manager: this
+    });
+  }
+  async setFullWork(e) {
+    const { workId: t, opt: s, toolsType: a } = e;
+    if (t && s && a) {
+      const r = t.toString();
+      let i;
+      const n = this.vNodes.get(r);
+      return !n || !n.workShape ? (i = this.createWorkShapeNode({
+        toolsOpt: s,
+        toolsType: y.BackgroundSVG,
+        workId: r
+      }), i && await i.init()) : (i = n.workShape, await i.setWorkOptions(s)), i;
+    }
+  }
+  async runFullWork(e) {
+    const { toolsType: t, opt: s, workId: a } = e;
+    await this.setFullWork({
+      toolsType: t,
+      opt: s,
+      workId: a
+    });
+  }
+  destroy() {
+    this.fullLayer.innerHTML = "", this.fullLayer.style.width = "", this.fullLayer.style.height = "";
+  }
+}
+class le {
+  constructor(e) {
+    h(this, "backgroundThreadMap", /* @__PURE__ */ new Map());
+    h(this, "snapshotThread");
+    h(this, "master");
+    h(this, "post", (e) => {
+      const { sp: t } = e;
+      t && this.master.collectorSyncData(t);
+    });
+    this.master = e, this.backgroundThreadMap = /* @__PURE__ */ new Map();
+  }
+  createBackgroundThread(e, t) {
+    return new j(e, t);
+  }
+  createSnapshotThread(e, t) {
+    return new Z(e, t);
+  }
+  async consume(e) {
+    var t, s, a, r, i, n;
+    for (const c of e.values()) {
+      const {
+        msgType: l,
+        viewId: m,
+        layerOpt: k,
+        offscreenCanvasOpt: w,
+        cameraOpt: p,
+        tasksqueue: u,
+        mainTasksqueueCount: O
+      } = c;
+      if (l === d.Console) {
+        console.log(this);
+        continue;
+      }
+      if (l === d.Init) {
+        const g = (t = this.master.control.viewContainerManager.getView(m)) == null ? void 0 : t.displayer, v = (s = g == null ? void 0 : g.backgroundContainerRef) == null ? void 0 : s.current;
+        if (g && v && k && w) {
+          const f = this.backgroundThreadMap.get(m);
+          f == null || f.destroy();
+          const S = this.createBackgroundThread(m, {
+            displayer: g,
+            container: v,
+            layerOpt: k,
+            master: this.master,
+            canvasOpt: w,
+            post: this.post
+          });
+          this.backgroundThreadMap.set(m, S), S && p && await S.setCameraOpt(p);
+        }
+        continue;
+      }
+      if (l === d.Snapshot) {
+        const g = (a = this.master.control.viewContainerManager.getView(m)) == null ? void 0 : a.displayer, f = (i = ((r = this.master.control.viewContainerManager.mainView) == null ? void 0 : r.displayer).backgroundSnapshotContainerRef) == null ? void 0 : i.current;
+        if (g && f && p) {
+          (n = this.snapshotThread) == null || n.destroy(), f.style.width = `${p.width}px`, f.style.height = `${p.height}px`;
+          const S = {
+            ...b.defaultLayerOpt,
+            offscreen: !1,
+            width: p.width,
+            height: p.height
+          }, E = {
+            ...b.defaultScreenCanvasOpt,
+            width: p.width,
+            height: p.height
+          };
+          this.snapshotThread = this.createSnapshotThread(m, {
+            displayer: g,
+            container: f,
+            layerOpt: S,
+            master: this.master,
+            canvasOpt: E,
+            post: this.post
+          }), await this.snapshotThread.getSnapshot(c), this.snapshotThread.destroy(), this.snapshotThread = void 0;
+          continue;
+        }
+      }
+      if (l === d.TasksQueue && (u != null && u.size)) {
+        for (const [g, v] of this.backgroundThreadMap.entries()) {
+          const f = u.get(g);
+          f && (await v.on(f), O && this.post({ workerTasksqueueCount: O }));
+        }
+        continue;
+      }
+      if (m === A) {
+        for (const g of this.backgroundThreadMap.values())
+          await g.on(c);
+        l === d.Destroy && this.backgroundThreadMap.clear();
+        continue;
+      }
+      const M = this.backgroundThreadMap.get(m);
+      M && (await M.on(c), l === d.Destroy && this.backgroundThreadMap.delete(m));
+    }
+  }
+  async consumeTargetOne(e, t) {
+    const s = this.backgroundThreadMap.get(e);
+    s && await s.on(t);
+  }
+  destroy() {
+    var e;
+    (e = this.snapshotThread) == null || e.destroy(), this.snapshotThread = void 0;
+    for (const t of this.backgroundThreadMap.values())
+      t.destroy();
+    this.backgroundThreadMap.clear();
+  }
+}
+export {
+  le as BackgroundThreadManagerImpl
+};