@libresign/pdf-elements 0.3.1 → 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1293 @@
+import { defineComponent as I, openBlock as m, createElementBlock as v, normalizeStyle as E, renderSlot as M, createElementVNode as P, withModifiers as R, createCommentVNode as $, normalizeClass as Y, Fragment as z, renderList as B, markRaw as y, resolveComponent as Z, createVNode as G, createBlock as J, withCtx as N, toDisplayString as U } from "vue";
+const Q = I({
+  name: "PDFPage",
+  emits: ["onMeasure"],
+  props: {
+    page: {
+      type: Object,
+      required: !0
+    },
+    scale: {
+      type: Number,
+      default: 1
+    }
+  },
+  data() {
+    return {
+      dynamicScale: this.scale,
+      isRendering: !1,
+      pendingRender: !1,
+      renderTask: null
+    };
+  },
+  watch: {
+    scale(e) {
+      this.dynamicScale = e, this.render();
+    }
+  },
+  mounted() {
+    this.render();
+  },
+  beforeUnmount() {
+    if (this.renderTask) {
+      try {
+        this.renderTask.cancel();
+      } catch {
+      }
+      this.renderTask = null;
+    }
+  },
+  methods: {
+    getCanvasMeasurement() {
+      return {
+        canvasWidth: this.$refs.canvas.width,
+        canvasHeight: this.$refs.canvas.height
+      };
+    },
+    measure() {
+      this.$emit("onMeasure", {
+        scale: this.dynamicScale
+      });
+    },
+    async render() {
+      if (this.isRendering) {
+        this.pendingRender = !0;
+        return;
+      }
+      this.isRendering = !0, this.pendingRender = !1;
+      try {
+        const e = await this.page, t = this.$refs.canvas;
+        if (!t) return;
+        if (this.renderTask) {
+          try {
+            this.renderTask.cancel();
+          } catch {
+          }
+          this.renderTask = null;
+        }
+        const i = t.getContext("2d");
+        if (!i) return;
+        const s = e.getViewport({
+          scale: this.dynamicScale
+        });
+        t.width = s.width, t.height = s.height, this.renderTask = e.render({
+          canvasContext: i,
+          viewport: s
+        }), await this.renderTask.promise, this.measure();
+      } finally {
+        this.isRendering = !1, this.renderTask = null, this.pendingRender && (this.pendingRender = !1, this.render());
+      }
+    }
+  }
+}), V = (e, t) => {
+  const i = e.__vccOpts || e;
+  for (const [s, o] of t)
+    i[s] = o;
+  return i;
+}, _ = { ref: "canvas" };
+function ee(e, t, i, s, o, a) {
+  return m(), v("canvas", _, null, 512);
+}
+const te = /* @__PURE__ */ V(Q, [["render", ee], ["__scopeId", "data-v-2a60d679"]]), ie = I({
+  name: "DraggableElement",
+  props: {
+    object: {
+      type: Object,
+      required: !0
+    },
+    pagesScale: {
+      type: Number,
+      default: 1
+    },
+    pageWidth: {
+      type: Number,
+      required: !0
+    },
+    pageHeight: {
+      type: Number,
+      required: !0
+    },
+    onUpdate: {
+      type: Function,
+      default: () => {
+      }
+    },
+    onDelete: {
+      type: Function,
+      default: () => {
+      }
+    },
+    onDuplicate: {
+      type: Function,
+      default: () => {
+      }
+    },
+    onDragStart: {
+      type: Function,
+      default: () => {
+      }
+    },
+    onDragMove: {
+      type: Function,
+      default: () => {
+      }
+    },
+    onDragEnd: {
+      type: Function,
+      default: () => {
+      }
+    },
+    isBeingDraggedGlobally: {
+      type: Boolean,
+      default: !1
+    },
+    draggingClientPos: {
+      type: Object,
+      default: () => ({ x: 0, y: 0 })
+    },
+    currentDocIndex: {
+      type: Number,
+      default: -1
+    },
+    currentPageIndex: {
+      type: Number,
+      default: -1
+    },
+    globalDragDocIndex: {
+      type: Number,
+      default: -1
+    },
+    globalDragPageIndex: {
+      type: Number,
+      default: -1
+    },
+    showSelectionUi: {
+      type: Boolean,
+      default: !0
+    },
+    showDefaultActions: {
+      type: Boolean,
+      default: !0
+    },
+    readOnly: {
+      type: Boolean,
+      default: !1
+    },
+    ignoreClickOutsideSelectors: {
+      type: Array,
+      default: () => []
+    }
+  },
+  data() {
+    return {
+      isSelected: !1,
+      mode: "idle",
+      direction: "",
+      startX: 0,
+      startY: 0,
+      startLeft: 0,
+      startTop: 0,
+      startWidth: 0,
+      startHeight: 0,
+      offsetX: 0,
+      offsetY: 0,
+      resizeOffsetX: 0,
+      resizeOffsetY: 0,
+      resizeOffsetW: 0,
+      resizeOffsetH: 0,
+      aspectRatio: 1,
+      lastMouseX: 0,
+      lastMouseY: 0,
+      pointerOffsetDoc: { x: 0, y: 0 },
+      currentPageRect: null,
+      rafId: null
+    };
+  },
+  computed: {
+    resizeDirections() {
+      return ["top-left", "top-right", "bottom-left", "bottom-right"];
+    },
+    elementStyle() {
+      const e = this.pagesScale || 1, t = this.mode === "drag", i = this.mode === "resize", s = t ? this.offsetX : 0, o = t ? this.offsetY : 0, a = i ? this.resizeOffsetX : 0, n = i ? this.resizeOffsetY : 0, h = i ? this.resizeOffsetW : 0, r = i ? this.resizeOffsetH : 0, l = this.object.x + s + a, u = this.object.y + o + n, c = this.object.width + h, d = this.object.height + r;
+      return {
+        left: `${l * e}px`,
+        top: `${u * e}px`,
+        width: `${c * e}px`,
+        height: `${d * e}px`,
+        pointerEvents: this.readOnly ? "none" : "auto"
+      };
+    },
+    toolbarStyle() {
+      const e = this.pagesScale || 1, t = this.mode === "drag", i = this.mode === "resize", s = t ? this.offsetX : 0, o = t ? this.offsetY : 0, a = i ? this.resizeOffsetX : 0, n = i ? this.resizeOffsetY : 0, h = i ? this.resizeOffsetW : 0, r = this.object.x + s + a, l = this.object.y + o + n, u = this.object.width + h, d = l - 60, g = d < 0 ? l + 8 : d;
+      return {
+        left: `${(r + u / 2) * e}px`,
+        top: `${g * e}px`,
+        transform: "translateX(-50%)"
+      };
+    },
+    dragElementStyle() {
+      return !this.isBeingDraggedGlobally || !this.draggingClientPos ? {} : {
+        opacity: 0,
+        pointerEvents: "none"
+      };
+    }
+  },
+  mounted() {
+    this.handleClickOutside = this.handleClickOutside.bind(this), this.boundHandleMove = this.handleMove.bind(this), this.boundStopInteraction = this.stopInteraction.bind(this), document.addEventListener("mousedown", this.handleClickOutside), document.addEventListener("touchstart", this.handleClickOutside);
+  },
+  beforeUnmount() {
+    document.removeEventListener("mousedown", this.handleClickOutside), document.removeEventListener("touchstart", this.handleClickOutside), window.removeEventListener("mousemove", this.boundHandleMove), window.removeEventListener("mouseup", this.boundStopInteraction), window.removeEventListener("touchmove", this.boundHandleMove), window.removeEventListener("touchend", this.boundStopInteraction), this.rafId && cancelAnimationFrame(this.rafId);
+  },
+  methods: {
+    handleElementClick(e) {
+      this.readOnly || e.target.closest(".delete-handle") || e.target.closest("[data-stop-drag]") || e.target.closest(".actions-toolbar") || (e.preventDefault(), this.isSelected = !0, this.startDrag(e));
+    },
+    handleClickOutside(e) {
+      const t = Array.isArray(this.ignoreClickOutsideSelectors) ? this.ignoreClickOutsideSelectors : [];
+      for (const i of t)
+        if (i && e?.target?.closest?.(i))
+          return;
+      this.$el && !this.$el.contains(e.target) && (this.isSelected = !1);
+    },
+    startResizeFromSlot(e, t) {
+      !e || !t || this.startResize(e, t);
+    },
+    startDrag(e) {
+      if (this.readOnly || e.target.classList.contains("delete") || e.target.classList.contains("resize-handle")) return;
+      this.mode = "drag", this.startX = e.type.includes("touch") ? e.touches[0].clientX : e.clientX, this.startY = e.type.includes("touch") ? e.touches[0].clientY : e.clientY, this.startLeft = this.object.x, this.startTop = this.object.y, this.offsetX = 0, this.offsetY = 0, this.resetResizeOffsets();
+      const t = this.$el.querySelector(".draggable-element").getBoundingClientRect();
+      this.pointerOffsetDoc.x = this.startX - t.left, this.pointerOffsetDoc.y = this.startY - t.top;
+      const i = this.capturePageRect();
+      this.currentPageRect = i;
+      let s = { x: 0, y: 0 };
+      if (i) {
+        const o = i.left + this.object.x * this.pagesScale, a = i.top + this.object.y * this.pagesScale;
+        s = {
+          x: t.left - o,
+          y: t.top - a
+        };
+      }
+      this.onDragStart(this.startX, this.startY, { ...this.pointerOffsetDoc }, s), window.addEventListener("mousemove", this.boundHandleMove), window.addEventListener("mouseup", this.boundStopInteraction), window.addEventListener("touchmove", this.boundHandleMove), window.addEventListener("touchend", this.boundStopInteraction);
+    },
+    startResize(e, t) {
+      this.readOnly || (this.mode = "resize", this.direction = e, this.startX = t.type.includes("touch") ? t.touches[0].clientX : t.clientX, this.startY = t.type.includes("touch") ? t.touches[0].clientY : t.clientY, this.startLeft = this.object.x, this.startTop = this.object.y, this.startWidth = this.object.width, this.startHeight = this.object.height, this.aspectRatio = this.startWidth / this.startHeight, this.offsetX = 0, this.offsetY = 0, this.resetResizeOffsets(), window.addEventListener("mousemove", this.boundHandleMove), window.addEventListener("mouseup", this.boundStopInteraction), window.addEventListener("touchmove", this.boundHandleMove), window.addEventListener("touchend", this.boundStopInteraction));
+    },
+    handleMove(e) {
+      this.mode !== "idle" && (e.preventDefault(), !this.rafId && (this.rafId = requestAnimationFrame(() => {
+        const t = e.type.includes("touch") ? e.touches[0]?.clientX : e.clientX, i = e.type.includes("touch") ? e.touches[0]?.clientY : e.clientY;
+        if (t === void 0 || i === void 0) return;
+        this.lastMouseX = t, this.lastMouseY = i;
+        const s = (t - this.startX) / this.pagesScale, o = (i - this.startY) / this.pagesScale;
+        if (this.mode === "drag") {
+          const c = this.currentPageRect;
+          if (c) {
+            const d = t - this.pointerOffsetDoc.x, g = i - this.pointerOffsetDoc.y, f = (d - c.left) / this.pagesScale, b = (g - c.top) / this.pagesScale;
+            this.offsetX = f - this.object.x, this.offsetY = b - this.object.y;
+          } else
+            this.offsetX = s, this.offsetY = o;
+          this.onDragMove(t, i), this.isBeingDraggedGlobally && this.onUpdate({
+            _globalDrag: !0,
+            _mouseX: t,
+            _mouseY: i
+          }), this.rafId = null;
+          return;
+        }
+        const a = 16 / (this.pagesScale || 1);
+        let n = this.startWidth, h = this.startHeight, r = this.startLeft, l = this.startTop;
+        const u = this.direction.includes("right") ? s : this.direction.includes("left") ? -s : 0;
+        if (n = this.startWidth + u, n < a && (n = a), h = n / this.aspectRatio, this.direction.includes("left") && (r = this.startLeft + (this.startWidth - n), r < 0)) {
+          const c = -r;
+          r = 0, n = n - c, h = n / this.aspectRatio;
+        }
+        if (this.direction.includes("top") && (l = this.startTop + (this.startHeight - h), l < 0)) {
+          const c = -l;
+          l = 0, h = h - c, n = h * this.aspectRatio, this.direction.includes("left") && (r = this.startLeft + (this.startWidth - n));
+        }
+        if (r + n > this.pageWidth) {
+          const c = r + n - this.pageWidth;
+          n -= c, h = n / this.aspectRatio;
+        }
+        if (l + h > this.pageHeight) {
+          const c = l + h - this.pageHeight;
+          h -= c, n = h * this.aspectRatio, this.direction.includes("left") && (r = this.startLeft + (this.startWidth - n));
+        }
+        this.resizeOffsetX = r - this.object.x, this.resizeOffsetY = l - this.object.y, this.resizeOffsetW = n - this.object.width, this.resizeOffsetH = h - this.object.height, this.rafId = null;
+      })));
+    },
+    stopInteraction() {
+      if (this.mode !== "idle") {
+        if (this.mode === "drag" && (this.offsetX !== 0 || this.offsetY !== 0))
+          if (this.isBeingDraggedGlobally)
+            this.onUpdate({
+              _globalDrag: !0,
+              _mouseX: this.lastMouseX,
+              _mouseY: this.lastMouseY
+            });
+          else {
+            const e = Math.max(0, Math.min(this.object.x + this.offsetX, this.pageWidth - this.object.width)), t = Math.max(0, Math.min(this.object.y + this.offsetY, this.pageHeight - this.object.height));
+            this.onUpdate({ x: e, y: t });
+          }
+        if (this.mode === "resize" && (this.resizeOffsetW !== 0 || this.resizeOffsetH !== 0 || this.resizeOffsetX !== 0 || this.resizeOffsetY !== 0)) {
+          const e = this.object.x + this.resizeOffsetX, t = this.object.y + this.resizeOffsetY, i = this.object.width + this.resizeOffsetW, s = this.object.height + this.resizeOffsetH;
+          this.onUpdate({ x: e, y: t, width: i, height: s });
+        }
+        this.resetOffsets(), this.onDragEnd(), window.removeEventListener("mousemove", this.boundHandleMove), window.removeEventListener("mouseup", this.boundStopInteraction), window.removeEventListener("touchmove", this.boundHandleMove), window.removeEventListener("touchend", this.boundStopInteraction);
+      }
+    },
+    capturePageRect() {
+      const e = this.$el.closest(".page-wrapper");
+      if (!e) return null;
+      const t = e.querySelector("canvas");
+      return t ? t.getBoundingClientRect() : null;
+    },
+    resetResizeOffsets() {
+      this.resizeOffsetX = 0, this.resizeOffsetY = 0, this.resizeOffsetW = 0, this.resizeOffsetH = 0;
+    },
+    resetOffsets() {
+      this.mode = "idle", this.offsetX = 0, this.offsetY = 0, this.resetResizeOffsets(), this.pointerOffsetDoc = { x: 0, y: 0 }, this.currentPageRect = null;
+    }
+  }
+}), se = { class: "draggable-wrapper" }, ne = ["onMousedown", "onTouchstart"];
+function oe(e, t, i, s, o, a) {
+  return m(), v("div", se, [
+    e.isSelected && !e.isBeingDraggedGlobally && e.showSelectionUi && e.showDefaultActions ? (m(), v("div", {
+      key: 0,
+      class: "actions-toolbar",
+      style: E(e.toolbarStyle)
+    }, [
+      M(e.$slots, "actions", {
+        object: e.object,
+        onDelete: e.onDelete,
+        onDuplicate: e.onDuplicate
+      }, () => [
+        P("button", {
+          class: "action-btn",
+          type: "button",
+          title: "Duplicate",
+          onClick: t[0] || (t[0] = R((...n) => e.onDuplicate && e.onDuplicate(...n), ["stop"]))
+        }, [...t[5] || (t[5] = [
+          P("svg", {
+            width: "16",
+            height: "16",
+            viewBox: "0 0 24 24",
+            fill: "currentColor"
+          }, [
+            P("path", { d: "M16 1H6a2 2 0 0 0-2 2v12h2V3h10V1zm3 4H10a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h9a2 2 0 0 0 2-2V7a2 2 0 0 0-2-2zm0 16H10V7h9v14z" })
+          ], -1)
+        ])]),
+        P("button", {
+          class: "action-btn",
+          type: "button",
+          title: "Delete",
+          onClick: t[1] || (t[1] = R((...n) => e.onDelete && e.onDelete(...n), ["stop"]))
+        }, [...t[6] || (t[6] = [
+          P("svg", {
+            width: "16",
+            height: "16",
+            viewBox: "0 0 16 16",
+            fill: "currentColor"
+          }, [
+            P("path", { d: "M6.5 1h3a.5.5 0 0 1 .5.5v1H6v-1a.5.5 0 0 1 .5-.5ZM11 2.5v-1A1.5 1.5 0 0 0 9.5 0h-3A1.5 1.5 0 0 0 5 1.5v1H2.5a.5.5 0 0 0 0 1h.5v10.5A1.5 1.5 0 0 0 4.5 15h7a1.5 1.5 0 0 0 1.5-1.5V3.5h.5a.5.5 0 0 0 0-1H11Zm1 1v10.5a.5.5 0 0 1-.5.5h-7a.5.5 0 0 1-.5-.5V3.5h8Z" })
+          ], -1)
+        ])])
+      ], !0)
+    ], 4)) : $("", !0),
+    P("div", {
+      class: Y(["draggable-element", { selected: e.isSelected && e.showSelectionUi }]),
+      draggable: "false",
+      onDragstart: t[2] || (t[2] = R(() => {
+      }, ["prevent"])),
+      style: E([e.elementStyle, e.dragElementStyle]),
+      onMousedown: t[3] || (t[3] = (...n) => e.handleElementClick && e.handleElementClick(...n)),
+      onTouchstart: t[4] || (t[4] = (...n) => e.handleElementClick && e.handleElementClick(...n))
+    }, [
+      M(e.$slots, "default", {
+        object: e.object,
+        isSelected: e.isSelected,
+        onDelete: e.onDelete,
+        onResize: e.startResizeFromSlot
+      }, void 0, !0),
+      e.isSelected && e.showSelectionUi ? (m(!0), v(z, { key: 0 }, B(e.resizeDirections, (n) => (m(), v("button", {
+        key: n,
+        class: Y(["resize-handle", `handle-${n}`]),
+        type: "button",
+        onMousedown: R((h) => e.startResize(n, h), ["stop", "prevent"]),
+        onTouchstart: R((h) => e.startResize(n, h), ["stop", "prevent"])
+      }, null, 42, ne))), 128)) : $("", !0)
+    ], 38)
+  ]);
+}
+const ae = /* @__PURE__ */ V(ie, [["render", oe], ["__scopeId", "data-v-c700849e"]]);
+let H = null, A = null, W = null, X = null;
+function re() {
+  return A || (A = import("./pdf-uHvE5neP.mjs")), A;
+}
+function he() {
+  return W || (W = import("./pdf.worker.min-DmO9Xdfo.mjs").then(
+    (e) => e.default
+  )), W;
+}
+async function le(e) {
+  if (X) {
+    e.GlobalWorkerOptions.workerSrc = X;
+    return;
+  }
+  e.GlobalWorkerOptions.workerSrc || (e.GlobalWorkerOptions.workerSrc = await he());
+}
+async function ce(e) {
+  return H || (await le(e), H = new e.PDFWorker({})), H;
+}
+function je(e) {
+  X = e, A && A.then((t) => {
+    t.GlobalWorkerOptions.workerSrc = e;
+  });
+}
+function K(e) {
+  return new Promise((t, i) => {
+    const s = new FileReader();
+    s.onload = () => t(s.result), s.onerror = i, s.readAsArrayBuffer(e);
+  });
+}
+async function x(e, t = {}) {
+  const i = await re(), s = await ce(i), o = e instanceof ArrayBuffer, a = ArrayBuffer.isView(e), n = typeof Blob < "u" && e instanceof Blob;
+  if (e && typeof e == "object" && !o && !a && !n)
+    return i.getDocument({ ...e, ...t, worker: s }).promise;
+  if (typeof e == "string")
+    return i.getDocument({ url: e, ...t, worker: s }).promise;
+  if (n) {
+    const r = await K(e);
+    return i.getDocument({ data: r, ...t, worker: s }).promise;
+  }
+  const h = o ? e : new Uint8Array(
+    e.buffer,
+    e.byteOffset,
+    e.byteLength
+  );
+  return i.getDocument({ data: h, ...t, worker: s }).promise;
+}
+function F(e, t, i, s, o, a) {
+  return {
+    x: Math.max(0, Math.min(e, o - i)),
+    y: Math.max(0, Math.min(t, a - s))
+  };
+}
+function de(e, t, i, s, o, a) {
+  const n = Math.max(0, e), h = Math.max(0, t), r = Math.min(o, e + i), l = Math.min(a, t + s);
+  return r <= n || l <= h ? 0 : (r - n) * (l - h);
+}
+function ge(e, t, i = 300) {
+  return {
+    minY: Math.max(0, e - i),
+    maxY: e + t + i
+  };
+}
+function ue(e, t, i, s) {
+  return !(e + t < i || e > s);
+}
+function q(e, t) {
+  e.forEach((i) => {
+    i.pagesScale = i.pagesScale.map(() => t);
+  });
+}
+function fe(e, t) {
+  return !e || !t ? !1 : e.allObjects.some((i) => i.some((s) => s.id === t));
+}
+function L(e, t) {
+  if (!(!e || !t)) {
+    for (let i = 0; i < e.allObjects.length; i++)
+      if (e.allObjects[i].some((s) => s.id === t))
+        return i;
+  }
+}
+function pe(e, t, i, s) {
+  const o = e?.allObjects?.[t];
+  if (!o) return !1;
+  const a = o.findIndex((n) => n.id === i);
+  return a === -1 ? !1 : (o.splice(a, 1, { ...o[a], ...s }), !0);
+}
+function me(e, t, i) {
+  const s = e?.allObjects?.[t];
+  if (!s) return !1;
+  const o = s.findIndex((a) => a.id === i);
+  return o === -1 ? !1 : (s.splice(o, 1), !0);
+}
+function ve(e, t, i, s) {
+  const o = e[t];
+  if (o)
+    return o;
+  const a = i.getCanvasMeasurement(), n = {
+    width: a.canvasWidth / s,
+    height: a.canvasHeight / s
+  };
+  return e[t] = n, n;
+}
+const we = I({
+  name: "PDFElements",
+  emits: ["pdf-elements:end-init", "pdf-elements:delete-object", "pdf-elements:object-click"],
+  components: {
+    PDFPage: te,
+    DraggableElement: ae
+  },
+  props: {
+    width: {
+      type: String,
+      default: "100%"
+    },
+    height: {
+      type: String,
+      default: "100%"
+    },
+    initFiles: {
+      type: Array,
+      default: () => []
+    },
+    initFileNames: {
+      type: Array,
+      default: () => []
+    },
+    initialScale: {
+      type: Number,
+      default: 1
+    },
+    showPageFooter: {
+      type: Boolean,
+      default: !0
+    },
+    hideSelectionUI: {
+      type: Boolean,
+      default: !1
+    },
+    showSelectionHandles: {
+      type: Boolean,
+      default: !0
+    },
+    showElementActions: {
+      type: Boolean,
+      default: !0
+    },
+    readOnly: {
+      type: Boolean,
+      default: !1
+    },
+    emitObjectClick: {
+      type: Boolean,
+      default: !1
+    },
+    ignoreClickOutsideSelectors: {
+      type: Array,
+      default: () => []
+    },
+    pageCountFormat: {
+      type: String,
+      default: "{currentPage} of {totalPages}"
+    },
+    autoFitZoom: {
+      type: Boolean,
+      default: !1
+    },
+    pdfjsOptions: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  data() {
+    return {
+      scale: this.initialScale,
+      pdfDocuments: [],
+      selectedDocIndex: -1,
+      selectedPageIndex: -1,
+      isAddingMode: !1,
+      previewElement: null,
+      previewPosition: { x: 0, y: 0 },
+      previewScale: { x: 1, y: 1 },
+      previewPageDocIndex: -1,
+      previewPageIndex: -1,
+      previewVisible: !1,
+      hoverRafId: 0,
+      pendingHoverClientPos: null,
+      lastHoverRect: null,
+      addingListenersAttached: !1,
+      dragRafId: 0,
+      pendingDragClientPos: null,
+      pageBoundsVersion: 0,
+      lastScrollTop: 0,
+      lastClientWidth: 0,
+      nextObjectCounter: 0,
+      isDraggingElement: !1,
+      draggingObject: null,
+      draggingDocIndex: -1,
+      draggingPageIndex: -1,
+      draggingClientPosition: { x: 0, y: 0 },
+      draggingScale: 1,
+      draggingInitialMouseOffset: { x: 0, y: 0 },
+      draggingElementShift: { x: 0, y: 0 },
+      lastMouseClientPos: { x: 0, y: 0 },
+      viewportRafId: 0,
+      objectIndexCache: y({}),
+      zoomRafId: null,
+      wheelZoomRafId: null,
+      boundHandleWheel: null,
+      visualScale: this.initialScale,
+      autoFitApplied: !1,
+      lastContainerWidth: 0,
+      _pagesBoundingRects: y({}),
+      _pagesBoundingRectsList: y([]),
+      _pageMeasurementCache: y({}),
+      _lastPageBoundsScrollTop: 0,
+      _lastPageBoundsClientHeight: 0
+    };
+  },
+  mounted() {
+    this.boundHandleWheel = this.handleWheel.bind(this), this.init(), window.addEventListener("scroll", this.onViewportScroll, { passive: !0 }), window.addEventListener("resize", this.onViewportScroll), this.$el?.addEventListener("scroll", this.onViewportScroll, { passive: !0 }), this.$el?.addEventListener("wheel", this.boundHandleWheel, { passive: !1 });
+  },
+  beforeUnmount() {
+    this.zoomRafId && cancelAnimationFrame(this.zoomRafId), this.wheelZoomRafId && (cancelAnimationFrame(this.wheelZoomRafId), this.wheelZoomRafId = null), this.boundHandleWheel && this.$el?.removeEventListener("wheel", this.boundHandleWheel), this.detachAddingListeners(), window.removeEventListener("scroll", this.onViewportScroll), window.removeEventListener("resize", this.onViewportScroll), this.$el?.removeEventListener("scroll", this.onViewportScroll), this.viewportRafId && (window.cancelAnimationFrame(this.viewportRafId), this.viewportRafId = 0), this.hoverRafId && (window.cancelAnimationFrame(this.hoverRafId), this.hoverRafId = 0), this.dragRafId && (window.cancelAnimationFrame(this.dragRafId), this.dragRafId = 0);
+  },
+  methods: {
+    async init() {
+      if (!this.initFiles || this.initFiles.length === 0) return;
+      const e = [];
+      this.autoFitApplied = !1;
+      for (let t = 0; t < this.initFiles.length; t++) {
+        const i = this.initFiles[t], s = this.initFileNames[t] || `document-${t + 1}.pdf`;
+        let o;
+        if (i instanceof Blob) {
+          const r = await K(i);
+          o = await x({ data: r }, this.pdfjsOptions);
+        } else
+          o = await x(i, this.pdfjsOptions);
+        const a = [], n = Array(o.numPages).fill(0);
+        for (let r = 1; r <= o.numPages; r++) {
+          const l = o.getPage(r);
+          l.then((u) => {
+            n.splice(r - 1, 1, u.getViewport({ scale: 1 }).width), this.autoFitZoom && this.scheduleAutoFitZoom();
+          }), a.push(l);
+        }
+        const h = y(a);
+        e.push({
+          name: s,
+          file: i,
+          pdfDoc: y(o),
+          numPages: o.numPages,
+          pages: h,
+          pageWidths: n,
+          pagesScale: Array(o.numPages).fill(this.scale),
+          allObjects: Array(o.numPages).fill(0).map(() => [])
+        });
+      }
+      this.pdfDocuments = e, this._pageMeasurementCache = y({}), e.length && (this.selectedDocIndex = 0, this.selectedPageIndex = 0, this.$emit("pdf-elements:end-init", { docsCount: e.length }), this.$nextTick(() => {
+        this.autoFitZoom && this.scheduleAutoFitZoom();
+      }));
+    },
+    selectPage(e, t) {
+      this.selectedDocIndex = e, this.selectedPageIndex = t;
+    },
+    startDraggingElement(e, t, i, s, o, a, n) {
+      this.isDraggingElement = !0, this.draggingObject = { ...i }, this.draggingDocIndex = e, this.draggingPageIndex = t, this.draggingScale = this.getDisplayedPageScale(e, t), this.lastMouseClientPos.x = s, this.lastMouseClientPos.y = o, this.draggingElementShift = n && typeof n.x == "number" && typeof n.y == "number" ? n : { x: 0, y: 0 }, this.cachePageBounds();
+      const h = this.getPageRect(e, t);
+      if (a && typeof a.x == "number" && typeof a.y == "number")
+        this.draggingInitialMouseOffset.x = a.x, this.draggingInitialMouseOffset.y = a.y, this.draggingClientPosition.x = s - this.draggingInitialMouseOffset.x, this.draggingClientPosition.y = o - this.draggingInitialMouseOffset.y;
+      else if (h) {
+        const r = h.left + i.x * this.draggingScale, l = h.top + i.y * this.draggingScale;
+        this.draggingInitialMouseOffset.x = s - r, this.draggingInitialMouseOffset.y = o - l, this.draggingClientPosition.x = s - this.draggingInitialMouseOffset.x, this.draggingClientPosition.y = o - this.draggingInitialMouseOffset.y;
+      }
+    },
+    updateDraggingPosition(e, t) {
+      this.isDraggingElement && (this.pendingDragClientPos ? (this.pendingDragClientPos.x = e, this.pendingDragClientPos.y = t) : this.pendingDragClientPos = { x: e, y: t }, !this.dragRafId && (this.dragRafId = window.requestAnimationFrame(() => {
+        this.dragRafId = 0;
+        const i = this.pendingDragClientPos;
+        i && (this.lastMouseClientPos.x = i.x, this.lastMouseClientPos.y = i.y, this.draggingClientPosition.x = i.x - this.draggingInitialMouseOffset.x, this.draggingClientPosition.y = i.y - this.draggingInitialMouseOffset.y);
+      })));
+    },
+    stopDraggingElement() {
+      if (this.draggingObject) {
+        const e = this.draggingObject.id, t = this.draggingDocIndex, i = this.checkAndMoveObjectPage(
+          this.draggingDocIndex,
+          e,
+          this.lastMouseClientPos.x,
+          this.lastMouseClientPos.y
+        );
+        i !== void 0 && this.$nextTick(() => {
+          this.selectPage(t, i);
+          const s = `draggable${t}-${i}-${e}`, o = this.$refs[s];
+          o && Array.isArray(o) && o[0] && (o[0].isSelected = !0);
+        });
+      }
+      this.isDraggingElement = !1, this.draggingObject = null, this.draggingDocIndex = -1, this.draggingPageIndex = -1, this.draggingElementShift = { x: 0, y: 0 }, this.pendingDragClientPos = null;
+    },
+    startAddingElement(e) {
+      this.pdfDocuments.length && (this.attachAddingListeners(), this.isAddingMode = !0, this.previewElement = { ...e }, this.previewPageDocIndex = 0, this.previewPageIndex = 0, this.previewVisible = !1, this.previewScale = { x: 1, y: 1 }, this.cachePageBounds());
+    },
+    cachePageBounds() {
+      const e = {}, t = [], i = this.$el, s = i?.scrollTop || 0, o = i?.clientHeight || 0;
+      if (!this.isAddingMode && !this.isDraggingElement && s === this._lastPageBoundsScrollTop && o === this._lastPageBoundsClientHeight)
+        return;
+      this._lastPageBoundsScrollTop = s, this._lastPageBoundsClientHeight = o;
+      const { minY: a, maxY: n } = ge(s, o);
+      for (let h = 0; h < this.pdfDocuments.length; h++)
+        for (let r = 0; r < this.pdfDocuments[h].pages.length; r++) {
+          const l = this.getPageCanvasElement(h, r);
+          if (!l) continue;
+          if (o) {
+            const d = l.closest(".page-wrapper") || l, g = d.offsetTop || 0, f = d.offsetHeight || 0;
+            if (!ue(g, f, a, n))
+              continue;
+          }
+          const u = l.getBoundingClientRect(), c = {
+            docIndex: h,
+            pageIndex: r,
+            rect: u
+          };
+          e[`${h}-${r}`] = c, t.push(c);
+        }
+      this._pagesBoundingRects = y(e), this._pagesBoundingRectsList = y(t), this.pageBoundsVersion++;
+    },
+    cachePageBoundsForPage(e, t) {
+      const i = this.getPageCanvasElement(e, t);
+      if (!i) return;
+      const s = i.getBoundingClientRect(), o = {
+        ...this._pagesBoundingRects,
+        [`${e}-${t}`]: {
+          docIndex: e,
+          pageIndex: t,
+          rect: s
+        }
+      };
+      this._pagesBoundingRects = y(o), this._pagesBoundingRectsList = y(Object.values(o)), this.pageBoundsVersion++;
+    },
+    getPageBoundsMap() {
+      return this._pagesBoundingRects || {};
+    },
+    getPageBoundsList() {
+      return this._pagesBoundingRectsList || [];
+    },
+    getPageRect(e, t) {
+      return this.getPageBoundsMap()[`${e}-${t}`]?.rect || null;
+    },
+    getPointerPosition(e) {
+      return e?.type?.includes?.("touch") ? {
+        x: e.touches?.[0]?.clientX,
+        y: e.touches?.[0]?.clientY
+      } : {
+        x: e?.clientX,
+        y: e?.clientY
+      };
+    },
+    getDisplayedPageScale(e, t) {
+      this.pageBoundsVersion;
+      const i = this.pdfDocuments[e];
+      if (!i) return 1;
+      const s = i.pageWidths?.[t] || 0;
+      this.getPageBoundsMap()[`${e}-${t}`] || this.cachePageBoundsForPage(e, t);
+      const a = this.getPageBoundsMap()[`${e}-${t}`]?.rect?.width || 0;
+      if (a && s)
+        return a / s;
+      if (this.isAddingMode || this.isDraggingElement) {
+        const l = this.getPageCanvasElement(e, t)?.getBoundingClientRect?.().width || 0;
+        if (l && s)
+          return l / s;
+      }
+      const n = i.pagesScale[t] || 1, h = this.visualScale && this.scale ? this.visualScale / this.scale : 1;
+      return n * h;
+    },
+    getPageComponent(e, t) {
+      const i = this.$refs[`page${e}-${t}`];
+      return i && Array.isArray(i) && i[0] ? i[0] : null;
+    },
+    getPageCanvasElement(e, t) {
+      const i = this.getPageComponent(e, t);
+      return i ? i.$el || i : null;
+    },
+    onViewportScroll() {
+      this.viewportRafId || (this.viewportRafId = window.requestAnimationFrame(() => {
+        const e = this.$el, t = e?.scrollTop || 0, i = e?.clientWidth || 0, s = t !== this.lastScrollTop, o = i !== this.lastClientWidth;
+        this.lastScrollTop = t, this.lastClientWidth = i, (this.isAddingMode || this.isDraggingElement) && (s || o) && this.cachePageBounds(), this.autoFitZoom && !this.isAddingMode && !this.isDraggingElement && i && o && (this.lastContainerWidth = i, this.autoFitApplied = !1, this.scheduleAutoFitZoom()), this.viewportRafId = 0;
+      }));
+    },
+    handleMouseMove(e) {
+      if (!this.isAddingMode || !this.previewElement) return;
+      const { x: t, y: i } = this.getPointerPosition(e);
+      t === void 0 || i === void 0 || (this.pendingHoverClientPos ? (this.pendingHoverClientPos.x = t, this.pendingHoverClientPos.y = i) : this.pendingHoverClientPos = { x: t, y: i }, !this.hoverRafId && (this.hoverRafId = window.requestAnimationFrame(() => {
+        this.hoverRafId = 0;
+        const s = this.pendingHoverClientPos;
+        if (!s) return;
+        const o = s.x, a = s.y;
+        let n = null;
+        if (this.lastHoverRect && o >= this.lastHoverRect.left && o <= this.lastHoverRect.right && a >= this.lastHoverRect.top && a <= this.lastHoverRect.bottom)
+          n = {
+            docIndex: this.previewPageDocIndex,
+            pageIndex: this.previewPageIndex,
+            rect: this.lastHoverRect
+          };
+        else {
+          const S = this.getPageBoundsList().length ? this.getPageBoundsList() : Object.values(this.getPageBoundsMap());
+          for (let w = 0; w < S.length; w++) {
+            const j = S[w], C = j.rect;
+            if (o >= C.left && o <= C.right && a >= C.top && a <= C.bottom) {
+              n = j;
+              break;
+            }
+          }
+        }
+        if (!n) {
+          this.previewVisible = !1, this.previewScale = { x: 1, y: 1 }, this.lastHoverRect = null;
+          return;
+        }
+        this.previewPageDocIndex = n.docIndex, this.previewPageIndex = n.pageIndex, this.lastHoverRect = n.rect;
+        const h = this.getPageCanvasElement(n.docIndex, n.pageIndex), r = this.pdfDocuments[n.docIndex]?.pagesScale?.[n.pageIndex] || 1, l = h?.width || n.rect.width, u = h?.height || n.rect.height, c = l ? n.rect.width / l : 1, d = u ? n.rect.height / u : 1, g = (o - n.rect.left) / c / r, f = (a - n.rect.top) / d / r, b = l / r, D = u / r;
+        this.previewScale.x = r, this.previewScale.y = r;
+        let p = g - this.previewElement.width / 2, O = f - this.previewElement.height / 2;
+        p = Math.max(0, Math.min(p, b - this.previewElement.width)), O = Math.max(0, Math.min(O, D - this.previewElement.height)), this.previewPosition.x = p, this.previewPosition.y = O, this.previewVisible = !0;
+      })));
+    },
+    handleOverlayClick(e, t, i) {
+      if (!this.emitObjectClick) return;
+      const { x: s, y: o } = this.getPointerPosition(i);
+      if (!Number.isFinite(s) || !Number.isFinite(o)) return;
+      this.cachePageBoundsForPage(e, t);
+      const a = this.getPageRect(e, t);
+      if (!a) return;
+      const n = this.getDisplayedPageScale(e, t) || 1, h = (s - a.left) / n, r = (o - a.top) / n, u = this.pdfDocuments?.[e]?.allObjects?.[t] || [];
+      if (u.length === 0) return;
+      let c = null;
+      for (let d = u.length - 1; d >= 0; d--) {
+        const g = u[d], f = Number(g.x), b = Number(g.y), D = Number(g.width), p = Number(g.height);
+        if ([f, b, D, p].every(Number.isFinite) && h >= f && h <= f + D && r >= b && r <= b + p) {
+          c = g;
+          break;
+        }
+      }
+      c && this.$emit("pdf-elements:object-click", {
+        docIndex: e,
+        pageIndex: t,
+        object: c,
+        event: i
+      });
+    },
+    handleKeyDown(e) {
+      e.key === "Escape" && this.isAddingMode && this.cancelAdding();
+    },
+    handleWheel(e) {
+      if (!e.ctrlKey) return;
+      e.preventDefault();
+      const t = 1 - e.deltaY * 2e-3, i = Math.max(0.5, Math.min(3, this.visualScale * t));
+      this.visualScale = i, !this.wheelZoomRafId && (this.wheelZoomRafId = window.requestAnimationFrame(() => {
+        this.wheelZoomRafId = null, this.commitZoom();
+      }));
+    },
+    commitZoom() {
+      const e = this.visualScale;
+      this.scale = e, q(this.pdfDocuments, this.scale), this._pageMeasurementCache = y({}), this.cachePageBounds();
+    },
+    finishAdding() {
+      if (!this.isAddingMode || !this.previewElement || !this.previewVisible) return;
+      const e = {
+        ...this.previewElement,
+        id: this.generateObjectId(),
+        x: Math.round(this.previewPosition.x),
+        y: Math.round(this.previewPosition.y)
+      }, t = this.pdfDocuments[this.previewPageDocIndex], i = this.getPageWidth(this.previewPageDocIndex, this.previewPageIndex), s = this.getPageHeight(this.previewPageDocIndex, this.previewPageIndex);
+      if (e.x < 0 || e.y < 0 || e.x + e.width > i || e.y + e.height > s) {
+        this.cancelAdding();
+        return;
+      }
+      t.allObjects[this.previewPageIndex].push(e);
+      const o = this.previewPageIndex, a = this.previewPageDocIndex, n = e.id;
+      this.cancelAdding(), this.$nextTick(() => {
+        const h = `draggable${a}-${o}-${n}`, r = this.$refs[h];
+        r && Array.isArray(r) && r[0] && (r[0].isSelected = !0);
+      });
+    },
+    cancelAdding() {
+      this.isAddingMode = !1, this.previewElement = null, this.previewVisible = !1, this.detachAddingListeners();
+    },
+    generateObjectId() {
+      const e = this.nextObjectCounter++, t = Math.random().toString(36).slice(2, 8);
+      return `obj-${Date.now()}-${e}-${t}`;
+    },
+    attachAddingListeners() {
+      this.addingListenersAttached || (this.addingListenersAttached = !0, document.addEventListener("mousemove", this.handleMouseMove), document.addEventListener("touchmove", this.handleMouseMove, { passive: !0 }), document.addEventListener("mouseup", this.finishAdding), document.addEventListener("touchend", this.finishAdding), document.addEventListener("keydown", this.handleKeyDown));
+    },
+    detachAddingListeners() {
+      this.addingListenersAttached && (this.addingListenersAttached = !1, document.removeEventListener("mousemove", this.handleMouseMove), document.removeEventListener("touchmove", this.handleMouseMove), document.removeEventListener("mouseup", this.finishAdding), document.removeEventListener("touchend", this.finishAdding), document.removeEventListener("keydown", this.handleKeyDown));
+    },
+    addObjectToPage(e, t = this.selectedPageIndex, i = this.selectedDocIndex) {
+      if (i < 0 || i >= this.pdfDocuments.length || t < 0 || t >= this.pdfDocuments[i].pages.length) return !1;
+      const s = this.pdfDocuments[i], o = this.getPageComponent(i, t);
+      if (!o) return !1;
+      let a = e;
+      (!a.id || this.objectIdExists(i, a.id)) && (a = { ...a, id: this.generateObjectId() });
+      const n = this.getCachedMeasurement(i, t, o), h = n.width, r = n.height;
+      return a.x < 0 || a.y < 0 || a.x + a.width > h || a.y + a.height > r ? !1 : (s.allObjects[t].push(a), this.objectIndexCache[`${i}-${a.id}`] = t, !0);
+    },
+    objectIdExists(e, t) {
+      if (!t) return !1;
+      const i = `${e}-${t}`;
+      if (this.objectIndexCache[i] !== void 0) return !0;
+      const s = this.pdfDocuments[e];
+      return fe(s, t);
+    },
+    updateObjectInPage(e, t, i, s) {
+      const o = this.pdfDocuments[e];
+      pe(o, t, i, s);
+    },
+    removeObjectFromPage(e, t, i) {
+      const s = this.pdfDocuments[e];
+      me(s, t, i);
+    },
+    getAllObjects(e = this.selectedDocIndex) {
+      if (e < 0 || e >= this.pdfDocuments.length) return [];
+      const t = this.pdfDocuments[e], i = [];
+      return t.allObjects.forEach((s, o) => {
+        const a = this.getPageComponent(e, o);
+        if (!a) return;
+        const h = this.getCachedMeasurement(e, o, a).height, r = t.pagesScale[o] || 1;
+        s.forEach((l) => {
+          i.push({
+            ...l,
+            pageIndex: o,
+            pageNumber: o + 1,
+            scale: r,
+            normalizedCoordinates: {
+              llx: Math.round(l.x),
+              lly: Math.round(h - l.y),
+              ury: Math.round(h - l.y - l.height),
+              width: Math.round(l.width),
+              height: Math.round(l.height)
+            }
+          });
+        });
+      }), i;
+    },
+    updateObject(e, t, i) {
+      if (e < 0 || e >= this.pdfDocuments.length) return;
+      const s = this.pdfDocuments[e], o = `${e}-${t}`;
+      let a = this.objectIndexCache[o];
+      if (a === void 0 && (a = L(s, t), a !== void 0 && (this.objectIndexCache[o] = a)), a === void 0) return;
+      const n = s.allObjects[a]?.find((h) => h.id === t);
+      if (n) {
+        if (i._globalDrag && i._mouseX !== void 0 && i._mouseY !== void 0) {
+          const h = i._mouseX, r = i._mouseY, l = this.getPageBoundsMap();
+          (!l || Object.keys(l).length === 0) && this.cachePageBounds();
+          const u = this.getPageRect(e, a);
+          if (u) {
+            const c = this.getDisplayedPageScale(e, a), d = (h - u.left - this.draggingElementShift.x) / c - this.draggingInitialMouseOffset.x / c, g = (r - u.top - this.draggingElementShift.y) / c - this.draggingInitialMouseOffset.y / c;
+            this.updateObjectInPage(e, a, t, { x: d, y: g });
+          }
+          return;
+        }
+        if (i.x !== void 0 || i.y !== void 0) {
+          const h = i.x !== void 0 ? i.x : n.x, r = i.y !== void 0 ? i.y : n.y, l = i.width !== void 0 ? i.width : n.width, u = i.height !== void 0 ? i.height : n.height, { width: c, height: d } = this.getPageSize(e, a);
+          if (h >= 0 && r >= 0 && h + l <= c && r + u <= d) {
+            this.updateObjectInPage(e, a, t, i);
+            return;
+          }
+          let g = a, f = 0;
+          for (let p = 0; p < s.pages.length; p++) {
+            const O = this.getPageWidth(e, p), S = this.getPageHeight(e, p), w = de(h, r, l, u, O, S);
+            w > f && (f = w, g = p);
+          }
+          if (g !== a) {
+            const { width: p, height: O } = this.getPageSize(e, g), { x: S, y: w } = F(h, r, l, u, p, O);
+            this.removeObjectFromPage(e, a, t);
+            const j = {
+              ...n,
+              ...i,
+              x: S,
+              y: w
+            };
+            s.allObjects[g].push(j), this.objectIndexCache[`${e}-${t}`] = g;
+            return;
+          }
+          const { width: b, height: D } = this.getPageSize(e, a);
+          if (h < 0 || r < 0 || h + l > b || r + u > D)
+            return;
+        }
+        this.updateObjectInPage(e, a, t, i);
+      }
+    },
+    deleteObject(e, t) {
+      if (e < 0 || e >= this.pdfDocuments.length) return;
+      const i = this.pdfDocuments[e];
+      let s = null, o = -1;
+      i.allObjects.some((a, n) => {
+        const h = a.findIndex((r) => r.id === t);
+        return h === -1 ? !1 : (s = a[h], o = n, a.splice(h, 1), !0);
+      }), delete this.objectIndexCache[`${e}-${t}`], s && this.$emit("pdf-elements:delete-object", {
+        object: s,
+        docIndex: e,
+        pageIndex: o
+      });
+    },
+    duplicateObject(e, t) {
+      if (e < 0 || e >= this.pdfDocuments.length) return;
+      const i = this.pdfDocuments[e], s = `${e}-${t}`;
+      let o = this.objectIndexCache[s];
+      if (o === void 0 && (o = L(i, t), o !== void 0 && (this.objectIndexCache[s] = o)), o === void 0) return;
+      const a = i.allObjects[o]?.find((g) => g.id === t);
+      if (!a) return;
+      const { width: n, height: h } = this.getPageSize(e, o), r = 12, { x: l, y: u } = F(
+        a.x + r,
+        a.y + r,
+        a.width,
+        a.height,
+        n,
+        h
+      );
+      let c = a.signer;
+      c?.element && Object.prototype.hasOwnProperty.call(c.element, "elementId") && (c = {
+        ...c,
+        element: { ...c.element }
+      }, delete c.element.elementId);
+      const d = {
+        ...a,
+        id: this.generateObjectId(),
+        x: l,
+        y: u,
+        signer: c
+      };
+      i.allObjects[o].push(d), this.objectIndexCache[`${e}-${d.id}`] = o, this.$nextTick(() => {
+        const g = `draggable${e}-${o}-${d.id}`, f = this.$refs[g];
+        f && Array.isArray(f) && f[0] && (f[0].isSelected = !0);
+      });
+    },
+    checkAndMoveObjectPage(e, t, i, s) {
+      if (e < 0 || e >= this.pdfDocuments.length) return;
+      const o = this.pdfDocuments[e], a = `${e}-${t}`;
+      let n = this.objectIndexCache[a];
+      if (n === void 0 && (n = L(o, t), n !== void 0 && (this.objectIndexCache[a] = n)), n === void 0) return;
+      const h = o.allObjects[n]?.find((w) => w.id === t);
+      if (!h) return n;
+      let r = n;
+      const l = this.getPageBoundsList(), u = this.getPageBoundsMap(), c = l.length ? l : Object.values(u);
+      for (let w = 0; w < c.length; w++) {
+        const { docIndex: j, pageIndex: C, rect: k } = c[w];
+        if (j === e && i >= k.left && i <= k.right && s >= k.top && s <= k.bottom) {
+          r = C;
+          break;
+        }
+      }
+      const d = this.getPageRect(e, r);
+      if (!d) return n;
+      const g = this.getDisplayedPageScale(e, r), f = (i - d.left - this.draggingElementShift.x) / g - this.draggingInitialMouseOffset.x / g, b = (s - d.top - this.draggingElementShift.y) / g - this.draggingInitialMouseOffset.y / g, { width: D, height: p } = this.getPageSize(e, r), { x: O, y: S } = F(
+        f,
+        b,
+        h.width,
+        h.height,
+        D,
+        p
+      );
+      return r !== n ? (this.removeObjectFromPage(e, n, t), o.allObjects[r].push({
+        ...h,
+        x: O,
+        y: S
+      }), this.objectIndexCache[a] = r) : (O !== h.x || S !== h.y) && this.updateObjectInPage(e, n, t, { x: O, y: S }), r;
+    },
+    onMeasure(e, t, i) {
+      t < 0 || t >= this.pdfDocuments.length || (this.pdfDocuments[t].pagesScale.splice(i, 1, e.scale), this._pageMeasurementCache[`${t}-${i}`] = null, this.cachePageBoundsForPage(t, i), this.autoFitZoom && this.scheduleAutoFitZoom());
+    },
+    formatPageNumber(e, t) {
+      return this.pageCountFormat.replace("{currentPage}", e).replace("{totalPages}", t);
+    },
+    getPageWidth(e, t) {
+      const i = this.getPageComponent(e, t);
+      return i ? this.getCachedMeasurement(e, t, i).width : 0;
+    },
+    getPageHeight(e, t) {
+      const i = this.getPageComponent(e, t);
+      return i ? this.getCachedMeasurement(e, t, i).height : 0;
+    },
+    getPageSize(e, t) {
+      return {
+        width: this.getPageWidth(e, t),
+        height: this.getPageHeight(e, t)
+      };
+    },
+    getCachedMeasurement(e, t, i) {
+      const s = `${e}-${t}`, a = this.pdfDocuments[e].pagesScale[t] || 1;
+      return ve(this._pageMeasurementCache, s, i, a);
+    },
+    calculateOptimalScale(e) {
+      const t = this.$el?.clientWidth || 0;
+      if (!t || !e) return 1;
+      const i = t - 40;
+      return Math.max(0.1, Math.min(2, i / e));
+    },
+    scheduleAutoFitZoom() {
+      this.autoFitApplied || this.zoomRafId || (this.zoomRafId = window.requestAnimationFrame(() => {
+        this.zoomRafId = 0, this.adjustZoomToFit();
+      }));
+    },
+    adjustZoomToFit() {
+      if (!this.autoFitZoom || this.autoFitApplied || !this.pdfDocuments.length) return;
+      const e = this.pdfDocuments.flatMap((s) => s.pageWidths || []).filter((s) => s > 0);
+      let t = 0;
+      if (e.length)
+        t = Math.max(...e);
+      else {
+        if (this.autoFitZoom) {
+          this.scheduleAutoFitZoom();
+          return;
+        }
+        const s = this.$el?.querySelectorAll("canvas");
+        if (!s?.length) return;
+        t = Math.max(...Array.from(s).map(
+          (o) => o.width / (this.scale || 1)
+        ));
+      }
+      const i = this.calculateOptimalScale(t);
+      this.autoFitApplied = !0, Math.abs(i - this.scale) > 0.01 && (this.scale = i, this.visualScale = i, q(this.pdfDocuments, this.scale), this._pageMeasurementCache = y({}), this.cachePageBounds());
+    }
+  }
+}), be = {
+  key: 0,
+  class: "pages-container"
+}, ye = ["onMousedown", "onTouchstart"], Pe = ["onClick", "onTouchend"], Oe = {
+  key: 0,
+  class: "page-footer"
+};
+function De(e, t, i, s, o, a) {
+  const n = Z("PDFPage"), h = Z("DraggableElement");
+  return m(), v("div", {
+    style: E({ width: e.width, height: e.height }),
+    class: "pdf-elements-root"
+  }, [
+    e.pdfDocuments.length ? (m(), v("div", be, [
+      (m(!0), v(z, null, B(e.pdfDocuments, (r, l) => (m(), v("div", { key: l }, [
+        (m(!0), v(z, null, B(r.pages, (u, c) => (m(), v("div", {
+          key: `${l}-${c}`,
+          class: "page-slot"
+        }, [
+          P("div", {
+            class: "page-wrapper",
+            onMousedown: (d) => e.selectPage(l, c),
+            onTouchstart: (d) => e.selectPage(l, c)
+          }, [
+            P("div", {
+              class: Y(["page-canvas", { "shadow-outline": l === e.selectedDocIndex && c === e.selectedPageIndex }])
+            }, [
+              G(n, {
+                ref_for: !0,
+                ref: `page${l}-${c}`,
+                page: u,
+                scale: e.scale,
+                onOnMeasure: (d) => e.onMeasure(d, l, c)
+              }, null, 8, ["page", "scale", "onOnMeasure"]),
+              P("div", {
+                class: "overlay",
+                onMousemove: t[0] || (t[0] = (...d) => e.handleMouseMove && e.handleMouseMove(...d)),
+                onTouchmove: t[1] || (t[1] = (...d) => e.handleMouseMove && e.handleMouseMove(...d)),
+                onClick: (d) => e.handleOverlayClick(l, c, d),
+                onTouchend: (d) => e.handleOverlayClick(l, c, d)
+              }, [
+                e.isAddingMode && e.previewPageDocIndex === l && e.previewPageIndex === c && e.previewElement && e.previewVisible ? (m(), v("div", {
+                  key: 0,
+                  class: "preview-element",
+                  style: E({
+                    left: `${e.previewPosition.x * e.previewScale.x}px`,
+                    top: `${e.previewPosition.y * e.previewScale.y}px`,
+                    width: `${e.previewElement.width * e.previewScale.x}px`,
+                    height: `${e.previewElement.height * e.previewScale.y}px`
+                  })
+                }, [
+                  M(e.$slots, e.previewElement.type ? `element-${e.previewElement.type}` : "custom", {
+                    object: e.previewElement,
+                    isSelected: !1
+                  }, () => [
+                    M(e.$slots, "custom", {
+                      object: e.previewElement,
+                      isSelected: !1
+                    }, void 0, !0)
+                  ], !0)
+                ], 4)) : $("", !0),
+                (m(!0), v(z, null, B(r.allObjects[c], (d) => (m(), J(h, {
+                  key: d.id,
+                  ref_for: !0,
+                  ref: `draggable${l}-${c}-${d.id}`,
+                  object: d,
+                  "pages-scale": e.getDisplayedPageScale(l, c),
+                  "page-width": e.getPageWidth(l, c),
+                  "page-height": e.getPageHeight(l, c),
+                  "read-only": e.readOnly,
+                  "on-update": (g) => e.updateObject(l, d.id, g),
+                  "on-delete": () => e.deleteObject(l, d.id),
+                  "on-duplicate": () => e.duplicateObject(l, d.id),
+                  "on-drag-start": (g, f, b, D) => e.startDraggingElement(l, c, d, g, f, b, D),
+                  "on-drag-move": e.updateDraggingPosition,
+                  "on-drag-end": e.stopDraggingElement,
+                  "is-being-dragged-globally": e.isDraggingElement && e.draggingObject && e.draggingObject.id === d.id,
+                  "dragging-client-pos": e.draggingClientPosition,
+                  "current-doc-index": l,
+                  "current-page-index": c,
+                  "global-drag-doc-index": e.draggingDocIndex,
+                  "global-drag-page-index": e.draggingPageIndex,
+                  "show-selection-ui": e.showSelectionHandles && !e.hideSelectionUI && d.resizable !== !1,
+                  "show-default-actions": e.showElementActions && !e.hideSelectionUI,
+                  "ignore-click-outside-selectors": e.ignoreClickOutsideSelectors
+                }, {
+                  default: N((g) => [
+                    M(e.$slots, g.object.type ? `element-${g.object.type}` : "custom", {
+                      object: g.object,
+                      onDelete: g.onDelete,
+                      onResize: g.onResize
+                    }, () => [
+                      M(e.$slots, "custom", {
+                        object: g.object,
+                        onDelete: g.onDelete,
+                        onResize: g.onResize
+                      }, void 0, !0)
+                    ], !0)
+                  ]),
+                  actions: N((g) => [
+                    M(e.$slots, "actions", {
+                      object: g.object,
+                      onDelete: g.onDelete,
+                      onDuplicate: g.onDuplicate
+                    }, void 0, !0)
+                  ]),
+                  _: 2
+                }, 1032, ["object", "pages-scale", "page-width", "page-height", "read-only", "on-update", "on-delete", "on-duplicate", "on-drag-start", "on-drag-move", "on-drag-end", "is-being-dragged-globally", "dragging-client-pos", "current-doc-index", "current-page-index", "global-drag-doc-index", "global-drag-page-index", "show-selection-ui", "show-default-actions", "ignore-click-outside-selectors"]))), 128))
+              ], 40, Pe)
+            ], 2),
+            e.showPageFooter ? (m(), v("div", Oe, [
+              P("span", null, U(r.name), 1),
+              P("span", null, U(e.formatPageNumber(c + 1, r.numPages)), 1)
+            ])) : $("", !0)
+          ], 40, ye)
+        ]))), 128))
+      ]))), 128))
+    ])) : $("", !0),
+    e.isDraggingElement && e.draggingObject ? (m(), v("div", {
+      key: 1,
+      class: "drag-portal",
+      style: E({
+        position: "fixed",
+        left: `${e.draggingClientPosition.x}px`,
+        top: `${e.draggingClientPosition.y}px`,
+        width: `${e.draggingObject.width * e.draggingScale}px`,
+        height: `${e.draggingObject.height * e.draggingScale}px`,
+        pointerEvents: "none"
+      })
+    }, [
+      M(e.$slots, e.draggingObject.type ? `element-${e.draggingObject.type}` : "custom", {
+        object: e.draggingObject,
+        isSelected: !1
+      }, () => [
+        M(e.$slots, "custom", {
+          object: e.draggingObject,
+          isSelected: !1
+        }, void 0, !0)
+      ], !0)
+    ], 4)) : $("", !0)
+  ], 4);
+}
+const T = /* @__PURE__ */ V(we, [["render", De], ["__scopeId", "data-v-eb792162"]]), Se = (e) => {
+  const t = T.name || "PDFElements";
+  e.component(t, T);
+};
+T.install = Se;
+export {
+  T as PDFElements,
+  T as default,
+  je as setWorkerPath
+};