@lancercomet/zoom-pan 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -0,0 +1,812 @@
+const t = async (t2, s2) => new Promise((i2, h2) => {
+  const e2 = new Image();
+  "string" == typeof t2 ? (void 0 !== s2 && (e2.crossOrigin = s2), e2.src = t2) : e2.src = URL.createObjectURL(t2), e2.onload = () => {
+    i2(e2);
+  }, e2.onerror = () => {
+    h2(new Error("Image load failed"));
+  };
+}), s = (t2, s2, i2) => Math.min(Math.max(t2, s2), i2);
+class i {
+  canvas;
+  context;
+  contentCanvas;
+  contentContext;
+  topScreenCanvas;
+  topScreenContext;
+  t;
+  i;
+  h;
+  o = [];
+  l = /* @__PURE__ */ new Map();
+  u = false;
+  M = false;
+  m;
+  p = true;
+  _ = 0;
+  v = performance.now();
+  L = 0;
+  R = 0;
+  S = 0;
+  C = 0;
+  A = Math.log(1);
+  T = Math.log(1);
+  LOG_MIN;
+  LOG_MAX;
+  P = /* @__PURE__ */ new Set();
+  B = /* @__PURE__ */ new Set();
+  I = /* @__PURE__ */ new Set();
+  get zoom() {
+    return Math.exp(this.A);
+  }
+  get minZoom() {
+    return this.i.minZoom;
+  }
+  get maxZoom() {
+    return this.i.maxZoom;
+  }
+  D = Math.max(1, window.devicePixelRatio || 1);
+  get dpr() {
+    return this.D;
+  }
+  use(t2) {
+    return this.l.has(t2.name) || (this.l.set(t2.name, t2), t2.install(this)), t2;
+  }
+  unuse(t2) {
+    const s2 = this.l.get(t2);
+    s2 && (s2.destroy(), this.l.delete(t2));
+  }
+  getPlugin(t2) {
+    return this.l.get(t2);
+  }
+  onUpdate(t2) {
+    this.P.add(t2);
+  }
+  offUpdate(t2) {
+    this.P.delete(t2);
+  }
+  onBeforeRender(t2) {
+    this.B.add(t2);
+  }
+  offBeforeRender(t2) {
+    this.B.delete(t2);
+  }
+  onAfterRender(t2) {
+    this.I.add(t2);
+  }
+  offAfterRender(t2) {
+    this.I.delete(t2);
+  }
+  requestRender() {
+    this.p = true;
+  }
+  F(t2) {
+    return s(t2, this.LOG_MIN, this.LOG_MAX);
+  }
+  k(t2, s2, i2) {
+    Number.isFinite(i2) && (this.S = t2, this.C = s2, this.T = this.F(i2), this.p = true);
+  }
+  zoomToAtScreen(t2, s2, i2) {
+    this.k(t2, s2, Math.log(i2));
+  }
+  zoomToAtScreenRaw(t2, i2, h2) {
+    if (!Number.isFinite(h2)) return;
+    const e2 = Math.max(1e-8, this.i.minZoom), n2 = this.i.maxZoom, r2 = s(h2, e2, n2), o2 = Math.exp(this.A), a2 = r2;
+    if (!Number.isFinite(o2) || o2 <= 0) return;
+    if (Math.abs(a2 - o2) < 1e-12) return;
+    const c2 = Math.log(r2);
+    this.A = c2, this.T = c2;
+    const l2 = a2 / o2;
+    this.L = t2 - (t2 - this.L) * l2, this.R = i2 - (i2 - this.R) * l2, this.p = true;
+  }
+  zoomToAtWorld(t2, s2, i2) {
+    const { x: h2, y: e2 } = this.toScreen(t2, s2);
+    this.zoomToAtScreen(h2, e2, i2);
+  }
+  zoomByFactorAtScreen(t2, s2, i2) {
+    if (i2 <= 0 || !Number.isFinite(i2)) return;
+    const h2 = Math.log(i2);
+    this.k(t2, s2, this.T + h2);
+  }
+  zoomByLogAtScreen(t2, s2, i2) {
+    this.k(t2, s2, this.T + i2);
+  }
+  zoomByFactorAtWorld(t2, s2, i2) {
+    const { x: h2, y: e2 } = this.toScreen(t2, s2);
+    this.zoomByFactorAtScreen(h2, e2, i2);
+  }
+  zoomInAtCenter() {
+    const t2 = this.canvas.getBoundingClientRect(), s2 = t2.width / 2, i2 = t2.height / 2;
+    this.zoomByFactorAtScreen(s2, i2, 1.2);
+  }
+  zoomOutAtCenter() {
+    const t2 = this.canvas.getBoundingClientRect(), s2 = t2.width / 2, i2 = t2.height / 2;
+    this.zoomByFactorAtScreen(s2, i2, 1 / 1.2);
+  }
+  panBy(t2, s2) {
+    this.L += t2, this.R += s2, this.p = true;
+  }
+  setPan(t2, s2) {
+    this.L = t2, this.R = s2, this.p = true;
+  }
+  setTransform(t2, i2, h2) {
+    const e2 = s(t2, this.i.minZoom, this.i.maxZoom);
+    this.A = Math.log(e2), this.T = this.A, this.L = i2, this.R = h2, this.p = true;
+  }
+  Z(t2, s2) {
+    t2.width === s2.width && t2.height === s2.height || (t2.width = s2.width, t2.height = s2.height);
+  }
+  U() {
+    if (this.M) return void (this._ = requestAnimationFrame(() => this.U()));
+    const t2 = performance.now(), s2 = Math.max(1, t2 - this.v);
+    this.v = t2;
+    const { approachKZoom: i2 } = this.i, h2 = Math.exp(this.A), e2 = this.T - this.A, n2 = Math.abs(e2) > 1e-6;
+    if (n2) {
+      const t3 = 1 - Math.exp(-i2 * s2);
+      this.A += e2 * t3;
+    }
+    const r2 = Math.exp(this.A);
+    if (r2 !== h2) {
+      const t3 = this.S, s3 = this.C, i3 = r2 / h2;
+      this.L = t3 - (t3 - this.L) * i3, this.R = s3 - (s3 - this.R) * i3;
+    }
+    if (this.u) {
+      const t3 = 1 - Math.exp(-this.i.approachKPan * s2);
+      this.L += (0 - this.L) * t3, this.R += (0 - this.R) * t3;
+      const i3 = Math.abs(this.A) < 1e-3 && Math.abs(this.T) < 1e-6, h3 = Math.abs(this.L) < 0.5 && Math.abs(this.R) < 0.5;
+      i3 && h3 && (this.A = 0, this.T = 0, this.L = 0, this.R = 0, this.u = false);
+    }
+    for (const t3 of this.P) t3(s2);
+    if (!(this.p || n2 || this.u)) return void (this._ = requestAnimationFrame(() => this.U()));
+    this.p = false;
+    const o2 = this.contentCanvas, a2 = this.contentContext, c2 = this.topScreenCanvas, l2 = this.topScreenContext, u2 = this.canvas, d2 = this.context;
+    this.Z(o2, u2), this.Z(c2, u2), a2.setTransform(1, 0, 0, 1, 0, 0), l2.setTransform(1, 0, 0, 1, 0, 0), d2.setTransform(1, 0, 0, 1, 0, 0);
+    const f2 = this.i.background;
+    "string" == typeof f2 && "" !== f2.trim() && "transparent" !== f2.toLowerCase() ? (d2.fillStyle = f2, d2.fillRect(0, 0, u2.width, u2.height)) : d2.clearRect(0, 0, u2.width, u2.height), a2.clearRect(0, 0, o2.width, o2.height), l2.clearRect(0, 0, c2.width, c2.height), a2.setTransform(this.D * r2, 0, 0, this.D * r2, this.D * this.L, this.D * this.R);
+    for (const t3 of this.B) t3(a2);
+    this.t(this);
+    for (const t3 of this.I) t3(a2);
+    d2.drawImage(o2, 0, 0), d2.drawImage(c2, 0, 0), this._ = requestAnimationFrame(() => this.U());
+  }
+  applyWorldTransform(t2) {
+    const s2 = Math.exp(this.A);
+    t2.setTransform(this.D * s2, 0, 0, this.D * s2, this.D * this.L, this.D * this.R);
+  }
+  applyScreenTransform(t2) {
+    t2.setTransform(this.D, 0, 0, this.D, 0, 0);
+  }
+  getPixelColorAtScreen(t2, s2) {
+    const i2 = Math.floor(t2 * this.D), h2 = Math.floor(s2 * this.D);
+    if (i2 < 0 || h2 < 0 || i2 >= this.canvas.width || h2 >= this.canvas.height) return { r: 0, g: 0, b: 0, a: 0, rgba: "rgba(0,0,0,0)", hex: "#000000" };
+    const e2 = this.contentContext.getImageData(i2, h2, 1, 1).data, n2 = e2[0], r2 = e2[1], o2 = e2[2], a2 = e2[3] / 255, c2 = (t3) => t3.toString(16).padStart(2, "0"), l2 = `#${c2(n2)}${c2(r2)}${c2(o2)}`;
+    return { r: n2, g: r2, b: o2, a: a2, rgba: `rgba(${n2},${r2},${o2},${a2.toFixed(3)})`, hex: l2 };
+  }
+  getPixelColorAtWorld(t2, s2) {
+    const { x: i2, y: h2 } = this.toScreen(t2, s2);
+    return this.getPixelColorAtScreen(i2, h2);
+  }
+  registerLayerManager(t2) {
+    t2 && (this.o.includes(t2) || (this.o.push(t2), this.p = true));
+  }
+  unregisterLayerManager(t2) {
+    const s2 = this.o.indexOf(t2);
+    s2 >= 0 && (this.o.splice(s2, 1), this.p = true);
+  }
+  getLayerManagers() {
+    return [...this.o];
+  }
+  resetSmooth() {
+    this.u = true, this.T = 0, this.p = true;
+  }
+  resetInstant() {
+    this.A = 0, this.T = 0, this.L = 0, this.R = 0, this.p = true;
+  }
+  toWorld(t2, s2) {
+    const i2 = Math.exp(this.A);
+    return { wx: (t2 - this.L) / i2, wy: (s2 - this.R) / i2 };
+  }
+  toScreen(t2, s2) {
+    const i2 = Math.exp(this.A);
+    return { x: t2 * i2 + this.L, y: s2 * i2 + this.R };
+  }
+  getTransform() {
+    return { zoom: Math.exp(this.A), tx: this.L, ty: this.R };
+  }
+  getViewportBounds() {
+    const t2 = Math.exp(this.A), s2 = this.canvas.width / this.D, i2 = this.canvas.height / this.D, h2 = -this.L / t2, e2 = -this.R / t2, n2 = (s2 - this.L) / t2, r2 = (i2 - this.R) / t2;
+    return { left: h2, top: e2, right: n2, bottom: r2, width: n2 - h2, height: r2 - e2 };
+  }
+  setZoomRange(t2, s2) {
+    this.i.minZoom = t2, this.i.maxZoom = s2, this.LOG_MIN = Math.log(t2), this.LOG_MAX = Math.log(s2), this.T = Math.min(this.LOG_MAX, Math.max(this.LOG_MIN, this.T));
+  }
+  resizeToParent() {
+    this.M = true;
+    const t2 = (this.canvas.parentElement || this.canvas).getBoundingClientRect();
+    this.D = Math.max(1, window.devicePixelRatio || 1);
+    const s2 = Math.max(1, Math.round(t2.width)), i2 = Math.max(1, Math.round(t2.height));
+    this.canvas.width = Math.round(s2 * this.D), this.canvas.height = Math.round(i2 * this.D), this.canvas.style.width = `${s2}px`, this.canvas.style.height = `${i2}px`, this.Z(this.contentCanvas, this.canvas), this.Z(this.topScreenCanvas, this.canvas), clearTimeout(this.m), this.m = window.setTimeout(() => {
+      this.M = false;
+    }, 50);
+  }
+  destroy() {
+    cancelAnimationFrame(this._);
+    for (const t2 of this.l.values()) t2.destroy();
+    this.l.clear(), this.h && this.h.disconnect(), this.o = [], this.P.clear(), this.B.clear(), this.I.clear();
+  }
+  constructor(t2, s2, i2) {
+    const h2 = t2.getContext("2d", { willReadFrequently: true, alpha: true });
+    if (!h2) throw new Error("2D context not available");
+    this.canvas = t2, this.context = h2, this.t = s2, this.contentCanvas = document.createElement("canvas"), this.contentCanvas.width = t2.width, this.contentCanvas.height = t2.height, this.contentContext = this.contentCanvas.getContext("2d", { alpha: true, willReadFrequently: true }), this.topScreenCanvas = document.createElement("canvas"), this.topScreenCanvas.width = t2.width, this.topScreenCanvas.height = t2.height, this.topScreenContext = this.topScreenCanvas.getContext("2d", { alpha: true }), this.i = { minZoom: 0.5, maxZoom: 10, approachKZoom: 0.022, approachKPan: 0.022, autoResize: true, background: "#fff", ...i2 }, this.LOG_MIN = Math.log(this.i.minZoom), this.LOG_MAX = Math.log(this.i.maxZoom), this.i.autoResize && (this.h = new ResizeObserver(() => this.resizeToParent()), this.h.observe(this.canvas.parentElement || this.canvas)), this.resizeToParent(), this.v = performance.now(), this._ = requestAnimationFrame(() => this.U());
+  }
+}
+let h = 0;
+class e {
+  id;
+  type;
+  name;
+  space = "world";
+  visible = true;
+  opacity = 1;
+  blend = "source-over";
+  constructor(t2, s2, i2 = "world") {
+    this.name = t2, this.id = `layer_${s2}_${++h}`, this.type = s2, this.space = i2;
+  }
+}
+class n extends e {
+  W;
+  canvas;
+  context;
+  x = 0;
+  y = 0;
+  scale = 1;
+  rotation = 0;
+  anchor = "topLeft";
+  $ = false;
+  q = 0;
+  O = 0;
+  beginStroke(t2, s2) {
+    const { lx: i2, ly: h2 } = this.toLocalPoint(t2, s2);
+    this.q = i2, this.O = h2, this.$ = true;
+  }
+  stroke(t2, s2, i2, h2, e2 = 1, n2 = "brush") {
+    if (!this.$) return;
+    const { lx: r2, ly: o2 } = this.toLocalPoint(t2, s2);
+    this.context.beginPath(), this.context.moveTo(this.q, this.O), this.context.lineTo(r2, o2), "eraser" === n2 ? (this.context.globalCompositeOperation = "destination-out", this.context.strokeStyle = "rgba(0, 0, 0, 1)") : (this.context.globalCompositeOperation = "source-over", this.context.strokeStyle = i2), this.context.lineWidth = h2 * e2, this.context.lineCap = "round", this.context.lineJoin = "round", this.context.stroke(), this.context.closePath(), this.q = r2, this.O = o2;
+  }
+  endStroke() {
+    this.$ = false;
+  }
+  isDrawing() {
+    return this.$;
+  }
+  captureSnapshot(t2) {
+    try {
+      if (t2) {
+        const { x: s2, y: i2, width: h2, height: e2 } = t2, n2 = Math.max(0, Math.floor(s2)), r2 = Math.max(0, Math.floor(i2)), o2 = Math.min(this.canvas.width - n2, Math.ceil(h2)), a2 = Math.min(this.canvas.height - r2, Math.ceil(e2));
+        return o2 <= 0 || a2 <= 0 ? null : this.context.getImageData(n2, r2, o2, a2);
+      }
+      return this.context.getImageData(0, 0, this.canvas.width, this.canvas.height);
+    } catch {
+      return null;
+    }
+  }
+  restoreSnapshot(t2, s2) {
+    const i2 = s2?.x ?? 0, h2 = s2?.y ?? 0;
+    this.context.putImageData(t2, i2, h2);
+  }
+  clearRegion(t2) {
+    t2 ? this.context.clearRect(t2.x, t2.y, t2.width, t2.height) : this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
+  }
+  requestRedraw() {
+    this.W?.(this.context, this.canvas);
+  }
+  drawImage(t2, s2, i2, h2, e2) {
+    this.context.drawImage(t2, s2, i2, h2 ?? t2.width, e2 ?? t2.height);
+  }
+  hitTest(t2, s2) {
+    const { lx: i2, ly: h2 } = this.toLocalPoint(t2, s2);
+    return i2 >= 0 && i2 <= this.canvas.width && h2 >= 0 && h2 <= this.canvas.height;
+  }
+  toLocalPoint(t2, s2) {
+    const i2 = t2 - this.x, h2 = s2 - this.y, e2 = Math.cos(-this.rotation), n2 = Math.sin(-this.rotation), r2 = i2 * n2 + h2 * e2, o2 = (i2 * e2 - h2 * n2) / this.scale, a2 = r2 / this.scale;
+    return { lx: o2 + ("center" === this.anchor ? this.canvas.width / 2 : 0), ly: a2 + ("center" === this.anchor ? this.canvas.height / 2 : 0) };
+  }
+  render(t2, s2) {
+    if (!this.visible) return;
+    const i2 = this.canvas.width * this.scale, h2 = this.canvas.height * this.scale, e2 = "center" === this.anchor ? -i2 / 2 : 0, n2 = "center" === this.anchor ? -h2 / 2 : 0;
+    t2.save(), t2.globalAlpha = this.opacity, t2.globalCompositeOperation = this.blend, t2.translate(this.x, this.y), t2.rotate(this.rotation), t2.drawImage(this.canvas, e2, n2, i2, h2), t2.restore();
+  }
+  cropTo(t2) {
+    const s2 = Math.max(1, Math.floor(t2.width)), i2 = Math.max(1, Math.floor(t2.height));
+    if (s2 === this.canvas.width && i2 === this.canvas.height) return;
+    const h2 = this.N(), e2 = Math.min(h2.width, s2), n2 = Math.min(h2.height, i2);
+    this.V(s2, i2), e2 > 0 && n2 > 0 && this.context.drawImage(h2, 0, 0, e2, n2, 0, 0, e2, n2);
+  }
+  resizeTo(t2) {
+    const s2 = Math.max(1, Math.floor(t2.width)), i2 = Math.max(1, Math.floor(t2.height));
+    if (s2 === this.canvas.width && i2 === this.canvas.height) return;
+    const h2 = this.N();
+    this.V(s2, i2), h2.width > 0 && h2.height > 0 && this.context.drawImage(h2, 0, 0, h2.width, h2.height, 0, 0, s2, i2);
+  }
+  N() {
+    const t2 = document.createElement("canvas");
+    if (t2.width = this.canvas.width, t2.height = this.canvas.height, 0 === t2.width || 0 === t2.height) return t2;
+    const s2 = t2.getContext("2d");
+    if (!s2) throw new Error("Offscreen 2D context unavailable");
+    return s2.drawImage(this.canvas, 0, 0), t2;
+  }
+  V(t2, s2) {
+    this.canvas.width = t2, this.canvas.height = s2, this.context.setTransform(1, 0, 0, 1, 0, 0), this.context.clearRect(0, 0, t2, s2);
+  }
+  destroy() {
+    this.canvas.width = 0, this.canvas.height = 0;
+  }
+  constructor(t2) {
+    super(t2.name || "", "canvas", t2.space ?? "world"), this.canvas = document.createElement("canvas"), this.canvas.width = t2.width, this.canvas.height = t2.height;
+    const s2 = this.canvas.getContext("2d", { willReadFrequently: true });
+    if (!s2) throw new Error("Offscreen 2D context unavailable");
+    this.context = s2, this.x = t2.x || 0, this.y = t2.y || 0, this.scale = t2.scale ?? 1, this.rotation = t2.rotation || 0, t2.anchor && (this.anchor = t2.anchor), this.W = t2.redraw, this.W && this.W(this.context, this.canvas);
+  }
+}
+class r extends n {
+  #t = null;
+  static async fromImage(s2) {
+    const i2 = await t(s2.src, s2.crossOrigin), h2 = s2.width ?? i2.naturalWidth, e2 = s2.height ?? i2.naturalHeight, n2 = new r({ name: s2.name, space: s2.space ?? "world", x: s2.x ?? 0, y: s2.y ?? 0, scale: s2.scale ?? 1, rotation: s2.rotation ?? 0, anchor: s2.anchor ?? "topLeft", width: h2, height: e2 });
+    return n2.context.clearRect(0, 0, n2.canvas.width, n2.canvas.height), n2.context.drawImage(i2, 0, 0, h2, e2), "string" != typeof s2.src && (n2.#t = i2.src.startsWith("blob:") ? i2.src : null), n2;
+  }
+  async setSource(s2, i2) {
+    const h2 = await t(s2, i2);
+    if (this.canvas.width = h2.naturalWidth, this.canvas.height = h2.naturalHeight, this.context.setTransform(1, 0, 0, 1, 0, 0), this.context.clearRect(0, 0, this.canvas.width, this.canvas.height), this.context.drawImage(h2, 0, 0), this.#t) {
+      try {
+        URL.revokeObjectURL(this.#t);
+      } catch {
+      }
+      this.#t = null;
+    }
+    "string" != typeof s2 && (this.#t = h2.src.startsWith("blob:") ? h2.src : null);
+  }
+  paint(t2) {
+    t2(this.context, this.canvas);
+  }
+  getImageData(t2 = 0, s2 = 0, i2 = this.canvas.width, h2 = this.canvas.height) {
+    return this.context.getImageData(t2, s2, i2, h2);
+  }
+  putImageData(t2, s2 = 0, i2 = 0) {
+    this.context.putImageData(t2, s2, i2);
+  }
+  toDataURL(t2 = "image/png", s2) {
+    return this.canvas.toDataURL(t2, s2);
+  }
+  toImageBitmap(t2) {
+    return createImageBitmap(this.canvas, t2 ?? {});
+  }
+  destroy() {
+    if (super.destroy?.(), this.#t) {
+      try {
+        URL.revokeObjectURL(this.#t);
+      } catch {
+      }
+      this.#t = null;
+    }
+  }
+  constructor(t2) {
+    super({ name: t2.name, space: t2.space ?? "world", x: t2.x, y: t2.y, scale: t2.scale, rotation: t2.rotation, anchor: t2.anchor ?? "topLeft", width: t2.width, height: t2.height }), this.type = "bitmap";
+  }
+}
+class o {
+  H = [];
+  X = [];
+  K(t2, s2) {
+    s2.save(), t2.applyWorldTransform(s2);
+    for (const i2 of this.H) !i2.visible || i2.opacity <= 0 || (s2.save(), i2.render(s2, t2), s2.restore());
+    s2.restore(), s2.save(), t2.applyScreenTransform(s2);
+    for (const i2 of this.X) !i2.visible || i2.opacity <= 0 || (s2.save(), i2.render(s2, t2), s2.restore());
+    s2.restore();
+  }
+  addLayer(t2, s2) {
+    const i2 = "world" === t2.space ? this.H : this.X;
+    return "number" == typeof s2 && s2 >= 0 && s2 < i2.length ? (i2.splice(s2, 0, t2), t2.id) : (i2.push(t2), t2.id);
+  }
+  async createImageLayer(t2) {
+    const s2 = await r.fromImage(t2);
+    return this.addLayer(s2), s2;
+  }
+  createCanvasLayer(t2) {
+    const s2 = new n(t2);
+    return this.addLayer(s2), s2;
+  }
+  removeLayer(t2) {
+    const s2 = this.H.findIndex((s3) => s3.id === t2);
+    if (s2 >= 0) return this.H[s2].destroy?.(), void this.H.splice(s2, 1);
+    const i2 = this.X.findIndex((s3) => s3.id === t2);
+    i2 >= 0 && (this.X[i2].destroy?.(), this.X.splice(i2, 1));
+  }
+  moveLayer(t2, s2) {
+    const i2 = this.H.findIndex((s3) => s3.id === t2);
+    if (i2 >= 0) {
+      const [t3] = this.H.splice(i2, 1), h3 = Math.max(0, Math.min(s2, this.H.length));
+      return void this.H.splice(h3, 0, t3);
+    }
+    const h2 = this.X.findIndex((s3) => s3.id === t2);
+    if (h2 >= 0) {
+      const [t3] = this.X.splice(h2, 1), i3 = Math.max(0, Math.min(s2, this.X.length));
+      this.X.splice(i3, 0, t3);
+    }
+  }
+  getLayer(t2) {
+    return this.H.find((s2) => s2.id === t2) || this.X.find((s2) => s2.id === t2);
+  }
+  getAllLayers(t2) {
+    return t2 ? ("world" === t2 ? this.H : this.X).slice() : [...this.H, ...this.X];
+  }
+  hitTest(t2, s2, i2 = "world") {
+    const h2 = this.getAllLayers(i2);
+    for (let i3 = h2.length - 1; i3 >= 0; i3--) {
+      const e2 = h2[i3];
+      if (e2.hitTest && e2.hitTest(t2, s2)) return e2;
+    }
+  }
+  destroy() {
+    for (const t2 of [...this.H, ...this.X]) t2.destroy?.();
+    this.H = [], this.X = [];
+  }
+}
+class a extends o {
+  Y = null;
+  G = null;
+  j = true;
+  J = 0;
+  tt = 0;
+  st = 0;
+  it = 0;
+  markDirty() {
+    this.j = true;
+  }
+  addLayer(t2, s2) {
+    return this.j = true, super.addLayer(t2, s2);
+  }
+  removeLayer(t2) {
+    this.j = true, super.removeLayer(t2);
+  }
+  moveLayer(t2, s2) {
+    this.j = true, super.moveLayer(t2, s2);
+  }
+  renderAllLayersIn(t2) {
+    const s2 = t2.contentContext, i2 = this.H;
+    0 !== i2.length && (this.j && this.ht(i2), this.Y && this.G && s2.drawImage(this.Y, this.st, this.it));
+  }
+  ht(t2) {
+    let s2 = 0, i2 = 0, h2 = 0, e2 = 0, n2 = false;
+    for (const r3 of t2) {
+      const t3 = r3, o3 = t3.canvas.width * t3.scale, a3 = t3.canvas.height * t3.scale, c2 = "center" === t3.anchor ? -o3 / 2 : 0, l2 = "center" === t3.anchor ? -a3 / 2 : 0, u2 = Math.cos(t3.rotation), d2 = Math.sin(t3.rotation), f2 = [{ x: c2, y: l2 }, { x: c2 + o3, y: l2 }, { x: c2, y: l2 + a3 }, { x: c2 + o3, y: l2 + a3 }];
+      let M2 = 1 / 0, m2 = 1 / 0, p2 = -1 / 0, g = -1 / 0;
+      for (const s3 of f2) {
+        const i3 = s3.x * u2 - s3.y * d2 + t3.x, h3 = s3.x * d2 + s3.y * u2 + t3.y;
+        M2 = Math.min(M2, i3), m2 = Math.min(m2, h3), p2 = Math.max(p2, i3), g = Math.max(g, h3);
+      }
+      n2 ? (s2 = Math.min(s2, M2), i2 = Math.min(i2, m2), h2 = Math.max(h2, p2), e2 = Math.max(e2, g)) : (s2 = M2, i2 = m2, h2 = p2, e2 = g, n2 = true);
+    }
+    if (!n2) return void (this.j = false);
+    const r2 = Math.ceil(h2 - s2), o2 = Math.ceil(e2 - i2);
+    this.Y || (this.Y = document.createElement("canvas"), this.G = this.Y.getContext("2d", { alpha: true })), this.J === r2 && this.tt === o2 || (this.Y.width = r2, this.Y.height = o2, this.J = r2, this.tt = o2), this.st = s2, this.it = i2;
+    const a2 = this.G;
+    a2.clearRect(0, 0, r2, o2), a2.save(), a2.translate(-s2, -i2);
+    for (const s3 of t2) !s3.visible || s3.opacity <= 0 || (a2.save(), s3.render(a2), a2.restore());
+    a2.restore(), this.j = false;
+  }
+  destroy() {
+    super.destroy(), this.Y = null, this.G = null;
+  }
+}
+class c extends o {
+  renderAllLayersIn(t2) {
+    const s2 = t2.topScreenContext;
+    this.K(t2, s2);
+  }
+}
+class l {
+  name = "interaction";
+  et = null;
+  i;
+  nt;
+  rt;
+  ot = false;
+  ct = 0;
+  lt = 0;
+  ut = 0;
+  dt = null;
+  ft = (t2) => this.Mt(t2);
+  gt = (t2) => this._t(t2);
+  yt = () => this.wt();
+  xt = (t2) => this.bt(t2);
+  constructor(t2) {
+    this.i = { panEnabled: true, zoomEnabled: true, friction: 0.92, stopSpeed: 0.02, emaAlpha: 0.25, idleNoInertiaMs: 120, wheelSensitivity: 15e-4, ...t2 }, this.nt = this.i.panEnabled, this.rt = this.i.zoomEnabled;
+  }
+  install(t2) {
+    this.et = t2;
+    const s2 = t2.canvas;
+    s2.addEventListener("wheel", this.xt, { passive: false }), s2.addEventListener("pointerdown", this.ft), window.addEventListener("pointermove", this.gt), window.addEventListener("pointerup", this.yt), t2.onUpdate(this.vt);
+  }
+  destroy() {
+    if (!this.et) return;
+    const t2 = this.et.canvas;
+    t2.removeEventListener("wheel", this.xt), t2.removeEventListener("pointerdown", this.ft), window.removeEventListener("pointermove", this.gt), window.removeEventListener("pointerup", this.yt), this.et.offUpdate(this.vt), this.et = null;
+  }
+  isPanEnabled() {
+    return this.nt;
+  }
+  isZoomEnabled() {
+    return this.rt;
+  }
+  setPanEnabled(t2) {
+    this.nt !== t2 && (this.nt = t2, t2 || (this.ot = false, this.ct = 0, this.lt = 0));
+  }
+  setZoomEnabled(t2) {
+    this.rt = t2;
+  }
+  setWheelSensitivity(t2) {
+    this.i.wheelSensitivity = t2;
+  }
+  isDragging() {
+    return this.ot;
+  }
+  vt = (t2) => {
+    if (!this.et) return;
+    const { friction: s2, stopSpeed: i2 } = this.i, h2 = Math.hypot(this.ct, this.lt) >= i2;
+    if (!this.ot && this.nt && h2) {
+      const h3 = this.ct * t2, e2 = this.lt * t2;
+      this.et.panBy(h3, e2), this.ct *= s2, this.lt *= s2, Math.hypot(this.ct, this.lt) < i2 && (this.ct = 0, this.lt = 0);
+    } else this.nt || (this.ct = 0, this.lt = 0);
+  };
+  Mt(t2) {
+    if (0 === t2.button && this.nt) {
+      this.ot = true, this.ct = 0, this.lt = 0, this.ut = performance.now(), this.dt = t2.pointerId;
+      try {
+        this.et?.canvas.setPointerCapture(t2.pointerId);
+      } catch {
+      }
+    }
+  }
+  _t(t2) {
+    if (!this.ot || !this.nt || !this.et) return;
+    const s2 = performance.now(), i2 = Math.max(1, s2 - (this.ut || s2 - 16));
+    this.ut = s2;
+    const h2 = t2.movementX, e2 = t2.movementY;
+    this.et.panBy(h2, e2);
+    const n2 = this.i.emaAlpha, r2 = h2 / i2, o2 = e2 / i2;
+    this.ct = (1 - n2) * this.ct + n2 * r2, this.lt = (1 - n2) * this.lt + n2 * o2;
+  }
+  wt() {
+    if (!this.ot) return;
+    this.ot = false;
+    const t2 = performance.now(), s2 = this.ut ? t2 - this.ut : 1 / 0;
+    if (null != this.dt && this.et) {
+      try {
+        this.et.canvas.releasePointerCapture(this.dt);
+      } catch {
+      }
+      this.dt = null;
+    }
+    if (s2 >= this.i.idleNoInertiaMs) this.ct = 0, this.lt = 0;
+    else {
+      const t3 = Math.pow(this.i.friction, s2 / 16);
+      this.ct *= t3, this.lt *= t3;
+    }
+    Math.hypot(this.ct, this.lt) < this.i.stopSpeed && (this.ct = 0, this.lt = 0);
+  }
+  Lt() {
+    if (!this.et) return 16;
+    const t2 = getComputedStyle(this.et.canvas).lineHeight;
+    if (!t2 || "normal" === t2) return 16;
+    const s2 = parseFloat(t2);
+    return Number.isFinite(s2) ? s2 : 16;
+  }
+  Rt(t2) {
+    if (!this.et) return 0;
+    let s2 = t2.deltaY;
+    return 1 === t2.deltaMode ? s2 *= this.Lt() : 2 === t2.deltaMode && (s2 *= this.et.canvas.clientHeight || window.innerHeight || 800), s2;
+  }
+  bt(t2) {
+    if (!this.rt || !this.et) return;
+    t2.preventDefault(), t2.stopPropagation();
+    const s2 = this.Rt(t2), i2 = this.et.canvas.getBoundingClientRect(), h2 = t2.clientX - i2.left, e2 = t2.clientY - i2.top;
+    let n2 = -s2 * this.i.wheelSensitivity;
+    t2.ctrlKey || t2.metaKey ? n2 *= 1.6 : t2.shiftKey && (n2 *= 0.6), this.et.zoomByLogAtScreen(h2, e2, n2);
+  }
+}
+function u(t2) {
+  return new l(t2);
+}
+class d {
+  name = "document";
+  et = null;
+  i;
+  St = false;
+  zt = 0;
+  Ct = 0;
+  At = 0;
+  Tt = 0;
+  Pt = 0;
+  Bt = 0;
+  It = 0;
+  Dt = 0;
+  Et = "minVisible";
+  constructor(t2) {
+    this.i = { rect: { x: 0, y: 0, width: 0, height: 0 }, margins: {}, drawBorder: false, minVisiblePx: 30, panClampMode: "minVisible", ...t2 }, t2?.rect && (this.St = true, this.zt = t2.rect.x, this.Ct = t2.rect.y, this.At = t2.rect.width, this.Tt = t2.rect.height), t2?.margins && (this.Pt = t2.margins.left ?? 0, this.Bt = t2.margins.right ?? 0, this.It = t2.margins.top ?? 0, this.Dt = t2.margins.bottom ?? 0), this.Et = this.i.panClampMode;
+  }
+  install(t2) {
+    this.et = t2, t2.onUpdate(this.vt), t2.onBeforeRender(this.Ft), t2.onAfterRender(this.kt);
+  }
+  destroy() {
+    this.et && (this.et.offUpdate(this.vt), this.et.offBeforeRender(this.Ft), this.et.offAfterRender(this.kt), this.et = null);
+  }
+  isEnabled() {
+    return this.St;
+  }
+  getRect() {
+    return { x: this.zt, y: this.Ct, width: this.At, height: this.Tt };
+  }
+  setRect(t2, s2, i2, h2) {
+    this.St = true, this.zt = t2, this.Ct = s2, this.At = i2, this.Tt = h2;
+  }
+  clearRect() {
+    this.St = false;
+  }
+  setMargins(t2) {
+    this.Pt = t2.left ?? this.Pt, this.Bt = t2.right ?? this.Bt, this.It = t2.top ?? this.It, this.Dt = t2.bottom ?? this.Dt;
+  }
+  getMargins() {
+    return { left: this.Pt, right: this.Bt, top: this.It, bottom: this.Dt };
+  }
+  setPanClampMode(t2) {
+    this.Et = t2;
+  }
+  getPanClampMode() {
+    return this.Et;
+  }
+  cropTo(t2) {
+    this.Zt("crop", t2);
+  }
+  resizeTo(t2) {
+    this.Zt("resize", t2);
+  }
+  zoomToFit(t2 = "contain") {
+    if (!this.St || !this.et) return;
+    const s2 = this.et.dpr, i2 = this.et.canvas.width / s2, h2 = this.et.canvas.height / s2, e2 = Math.max(1, i2 - (this.Pt + this.Bt)), n2 = Math.max(1, h2 - (this.It + this.Dt));
+    let r2;
+    const o2 = e2 / this.At, a2 = n2 / this.Tt;
+    r2 = "contain" === t2 ? Math.min(o2, a2) : "cover" === t2 ? Math.max(o2, a2) : "fitWidth" === t2 ? o2 : a2, r2 = Math.min(this.et.maxZoom, Math.max(this.et.minZoom, r2));
+    const c2 = this.Pt + (e2 - r2 * this.At) / 2, l2 = this.It + (n2 - r2 * this.Tt) / 2, u2 = c2 - r2 * this.zt, d2 = l2 - r2 * this.Ct;
+    this.et.setTransform(r2, u2, d2);
+  }
+  isPointInDocument(t2, s2) {
+    return !this.St || t2 >= this.zt && t2 <= this.zt + this.At && s2 >= this.Ct && s2 <= this.Ct + this.Tt;
+  }
+  vt = () => {
+    this.St && this.et && this.Ut();
+  };
+  Ft = (t2) => {
+    this.St && this.et && (t2.save(), t2.beginPath(), t2.rect(this.zt, this.Ct, this.At, this.Tt), t2.clip());
+  };
+  kt = (t2) => {
+    if (this.St && this.et && (t2.restore(), this.i.drawBorder)) {
+      const s2 = this.et.zoom;
+      t2.save(), t2.lineWidth = 1 / s2, t2.strokeStyle = "#cfcfcf", t2.strokeRect(this.zt, this.Ct, this.At, this.Tt), t2.restore();
+    }
+  };
+  Ut() {
+    if (!this.et) return;
+    const { zoom: t2, tx: s2, ty: i2 } = this.et.getTransform(), h2 = t2, e2 = this.et.dpr, n2 = this.et.canvas.width / e2, r2 = this.et.canvas.height / e2, o2 = this.zt, a2 = this.Ct, c2 = this.zt + this.At, l2 = this.Ct + this.Tt;
+    let u2 = s2, d2 = i2;
+    if ("margin" === this.Et) {
+      const t3 = this.Pt - h2 * o2, e3 = n2 - this.Bt - h2 * c2, f2 = this.It - h2 * a2, M2 = r2 - this.Dt - h2 * l2, m2 = Math.max(1, n2 - (this.Pt + this.Bt)), p2 = Math.max(1, r2 - (this.It + this.Dt));
+      u2 = h2 * this.At <= m2 ? this.Pt + (m2 - h2 * this.At) / 2 - h2 * this.zt : Math.min(t3, Math.max(e3, s2)), d2 = h2 * this.Tt <= p2 ? this.It + (p2 - h2 * this.Tt) / 2 - h2 * this.Ct : Math.min(f2, Math.max(M2, i2));
+    } else if ("minVisible" === this.Et) {
+      const t3 = h2 * this.At, e3 = h2 * this.Tt, f2 = Math.min(this.i.minVisiblePx, t3), M2 = Math.min(this.i.minVisiblePx, e3), m2 = n2 - f2 - h2 * o2, p2 = f2 - h2 * c2, g = r2 - M2 - h2 * a2, _ = M2 - h2 * l2;
+      u2 = p2 <= m2 ? Math.min(m2, Math.max(p2, s2)) : (p2 + m2) / 2, d2 = _ <= g ? Math.min(g, Math.max(_, i2)) : (_ + g) / 2;
+    }
+    u2 === s2 && d2 === i2 || this.et.setPan(u2, d2);
+  }
+  Zt(t2, s2) {
+    if (!this.et) return;
+    const i2 = Math.max(1, Math.floor(s2.width)), h2 = Math.max(1, Math.floor(s2.height)), e2 = { width: i2, height: h2 }, n2 = this.et.getLayerManagers();
+    for (const s3 of n2) {
+      const i3 = s3.getAllLayers("world");
+      for (const s4 of i3) {
+        const i4 = s4;
+        "function" == typeof i4.cropTo && "function" == typeof i4.resizeTo && ("crop" === t2 ? i4.cropTo(e2) : i4.resizeTo(e2));
+      }
+    }
+    this.At = i2, this.Tt = h2, this.St && this.Ut();
+  }
+}
+function f(t2) {
+  return new d(t2);
+}
+class M {
+  type = "snapshot";
+  Wt;
+  $t;
+  qt;
+  Ot;
+  Nt = true;
+  constructor(t2, s2, i2, h2) {
+    this.Wt = t2, this.$t = s2, this.qt = i2, this.Ot = h2?.region;
+  }
+  execute() {
+    if (this.Nt) return;
+    const t2 = this.Ot ? { x: this.Ot.x, y: this.Ot.y } : void 0;
+    this.Wt.restoreSnapshot(this.qt, t2), this.Nt = true;
+  }
+  undo() {
+    if (!this.Nt) return;
+    const t2 = this.Ot ? { x: this.Ot.x, y: this.Ot.y } : void 0;
+    this.Wt.restoreSnapshot(this.$t, t2), this.Nt = false;
+  }
+  canMerge() {
+    return false;
+  }
+  merge() {
+    return this;
+  }
+}
+function m(t2, s2, i2, h2) {
+  return s2 && i2 ? new M(t2, s2, i2, h2) : null;
+}
+class p {
+  Vt;
+  Ht = [];
+  Xt = [];
+  executeCommand(t2) {
+    t2.execute(), this.addCommand(t2);
+  }
+  addCommand(t2) {
+    this.Xt = [];
+    const s2 = this.Ht[this.Ht.length - 1];
+    if (s2 && s2.canMerge?.(t2) && s2.merge) {
+      const i2 = s2.merge(t2) ?? s2;
+      return void (i2 !== s2 && (this.Ht[this.Ht.length - 1] = i2));
+    }
+    this.Ht.push(t2), this.Ht.length > this.Vt && this.Ht.shift();
+  }
+  undo() {
+    if (0 === this.Ht.length) return null;
+    const t2 = this.Ht.pop();
+    return t2.undo(), this.Xt.push(t2), t2;
+  }
+  redo() {
+    if (0 === this.Xt.length) return null;
+    const t2 = this.Xt.pop();
+    return t2.execute(), this.Ht.push(t2), t2;
+  }
+  canUndo() {
+    return this.Ht.length > 0;
+  }
+  canRedo() {
+    return this.Xt.length > 0;
+  }
+  clear() {
+    this.Ht = [], this.Xt = [];
+  }
+  setMaxHistorySize(t2) {
+    this.Vt = Math.max(1, t2), this.Ht.length > this.Vt && (this.Ht = this.Ht.slice(-this.Vt));
+  }
+  constructor(t2) {
+    this.Vt = t2?.maxHistorySize ?? 50, this.Ht = t2?.undoStack ?? [], this.Xt = t2?.redoStack ?? [];
+  }
+}
+export {
+  r as BitmapLayer,
+  n as CanvasLayer,
+  a as ContentLayerManager,
+  d as DocumentPlugin,
+  p as HistoryManager,
+  l as InteractionPlugin,
+  e as LayerBase,
+  o as LayerManagerBase,
+  M as SnapshotCommand,
+  c as TopScreenLayerManager,
+  i as ViewManager,
+  f as createDocumentPlugin,
+  u as createInteractionPlugin,
+  m as createSnapshotCommand
+};