@bagelink/vue 1.15.440 → 1.15.447

package/dist/page-flip.browser-BXnk8BM6.js

@@ -0,0 +1,1381 @@
+import { t as W } from "./chunk-Fx_iipZ-.js";
+var E = /* @__PURE__ */ W(((m, I) => {
+  (function(u, c) {
+    typeof m == "object" && typeof I < "u" ? c(m) : typeof define == "function" && define.amd ? define(["exports"], c) : c((u = u || self).St = {});
+  })(m, (function(u) {
+    "use strict";
+    class c {
+      constructor(t, e) {
+        this.state = {
+          angle: 0,
+          area: [],
+          position: {
+            x: 0,
+            y: 0
+          },
+          hardAngle: 0,
+          hardDrawingAngle: 0
+        }, this.createdDensity = e, this.nowDrawingDensity = this.createdDensity, this.render = t;
+      }
+      setDensity(t) {
+        this.createdDensity = t, this.nowDrawingDensity = t;
+      }
+      setDrawingDensity(t) {
+        this.nowDrawingDensity = t;
+      }
+      setPosition(t) {
+        this.state.position = t;
+      }
+      setAngle(t) {
+        this.state.angle = t;
+      }
+      setArea(t) {
+        this.state.area = t;
+      }
+      setHardDrawingAngle(t) {
+        this.state.hardDrawingAngle = t;
+      }
+      setHardAngle(t) {
+        this.state.hardAngle = t, this.state.hardDrawingAngle = t;
+      }
+      setOrientation(t) {
+        this.orientation = t;
+      }
+      getDrawingDensity() {
+        return this.nowDrawingDensity;
+      }
+      getDensity() {
+        return this.createdDensity;
+      }
+      getHardAngle() {
+        return this.state.hardAngle;
+      }
+    }
+    class T extends c {
+      constructor(t, e, i) {
+        super(t, i), this.image = null, this.isLoad = !1, this.loadingAngle = 0, this.image = new Image(), this.image.src = e;
+      }
+      draw(t) {
+        const e = this.render.getContext(), i = this.render.convertToGlobal(this.state.position), s = this.render.getRect().pageWidth, n = this.render.getRect().height;
+        e.save(), e.translate(i.x, i.y), e.beginPath();
+        for (let h of this.state.area) h !== null && (h = this.render.convertToGlobal(h), e.lineTo(h.x - i.x, h.y - i.y));
+        e.rotate(this.state.angle), e.clip(), this.isLoad ? e.drawImage(this.image, 0, 0, s, n) : this.drawLoader(e, {
+          x: 0,
+          y: 0
+        }, s, n), e.restore();
+      }
+      simpleDraw(t) {
+        const e = this.render.getRect(), i = this.render.getContext(), s = e.pageWidth, n = e.height, h = t === 1 ? e.left + e.pageWidth : e.left, o = e.top;
+        this.isLoad ? i.drawImage(this.image, h, o, s, n) : this.drawLoader(i, {
+          x: h,
+          y: o
+        }, s, n);
+      }
+      drawLoader(t, e, i, s) {
+        t.beginPath(), t.strokeStyle = "rgb(200, 200, 200)", t.fillStyle = "rgb(255, 255, 255)", t.lineWidth = 1, t.rect(e.x + 1, e.y + 1, i - 1, s - 1), t.stroke(), t.fill();
+        const n = {
+          x: e.x + i / 2,
+          y: e.y + s / 2
+        };
+        t.beginPath(), t.lineWidth = 10, t.arc(n.x, n.y, 20, this.loadingAngle, 3 * Math.PI / 2 + this.loadingAngle), t.stroke(), t.closePath(), this.loadingAngle += 0.07, this.loadingAngle >= 2 * Math.PI && (this.loadingAngle = 0);
+      }
+      load() {
+        this.isLoad || (this.image.onload = () => {
+          this.isLoad = !0;
+        });
+      }
+      newTemporaryCopy() {
+        return this;
+      }
+      getTemporaryCopy() {
+        return this;
+      }
+      hideTemporaryCopy() {
+      }
+    }
+    class f {
+      constructor(t, e) {
+        this.pages = [], this.currentPageIndex = 0, this.currentSpreadIndex = 0, this.landscapeSpread = [], this.portraitSpread = [], this.render = e, this.app = t, this.currentPageIndex = 0, this.isShowCover = this.app.getSettings().showCover;
+      }
+      destroy() {
+        this.pages = [];
+      }
+      createSpread() {
+        this.landscapeSpread = [], this.portraitSpread = [];
+        for (let e = 0; e < this.pages.length; e++) this.portraitSpread.push([e]);
+        let t = 0;
+        this.isShowCover && (this.pages[0].setDensity("hard"), this.landscapeSpread.push([t]), t++);
+        for (let e = t; e < this.pages.length; e += 2) e < this.pages.length - 1 ? this.landscapeSpread.push([e, e + 1]) : (this.landscapeSpread.push([e]), this.pages[e].setDensity("hard"));
+      }
+      getSpread() {
+        return this.render.getOrientation() === "landscape" ? this.landscapeSpread : this.portraitSpread;
+      }
+      getSpreadIndexByPage(t) {
+        const e = this.getSpread();
+        for (let i = 0; i < e.length; i++) if (t === e[i][0] || t === e[i][1]) return i;
+        return null;
+      }
+      getPageCount() {
+        return this.pages.length;
+      }
+      getPages() {
+        return this.pages;
+      }
+      getPage(t) {
+        if (t >= 0 && t < this.pages.length) return this.pages[t];
+        throw new Error("Invalid page number");
+      }
+      nextBy(t) {
+        const e = this.pages.indexOf(t);
+        return e < this.pages.length - 1 ? this.pages[e + 1] : null;
+      }
+      prevBy(t) {
+        const e = this.pages.indexOf(t);
+        return e > 0 ? this.pages[e - 1] : null;
+      }
+      getFlippingPage(t) {
+        const e = this.currentSpreadIndex;
+        if (this.render.getOrientation() === "portrait") return t === 0 ? this.pages[e].newTemporaryCopy() : this.pages[e - 1];
+        {
+          const i = t === 0 ? this.getSpread()[e + 1] : this.getSpread()[e - 1];
+          return i.length === 1 || t === 0 ? this.pages[i[0]] : this.pages[i[1]];
+        }
+      }
+      getBottomPage(t) {
+        const e = this.currentSpreadIndex;
+        if (this.render.getOrientation() === "portrait") return t === 0 ? this.pages[e + 1] : this.pages[e - 1];
+        {
+          const i = t === 0 ? this.getSpread()[e + 1] : this.getSpread()[e - 1];
+          return i.length === 1 ? this.pages[i[0]] : t === 0 ? this.pages[i[1]] : this.pages[i[0]];
+        }
+      }
+      showNext() {
+        this.currentSpreadIndex < this.getSpread().length && (this.currentSpreadIndex++, this.showSpread());
+      }
+      showPrev() {
+        this.currentSpreadIndex > 0 && (this.currentSpreadIndex--, this.showSpread());
+      }
+      getCurrentPageIndex() {
+        return this.currentPageIndex;
+      }
+      show(t = null) {
+        if (t === null && (t = this.currentPageIndex), t < 0 || t >= this.pages.length) return;
+        const e = this.getSpreadIndexByPage(t);
+        e !== null && (this.currentSpreadIndex = e, this.showSpread());
+      }
+      getCurrentSpreadIndex() {
+        return this.currentSpreadIndex;
+      }
+      setCurrentSpreadIndex(t) {
+        if (!(t >= 0 && t < this.getSpread().length)) throw new Error("Invalid page");
+        this.currentSpreadIndex = t;
+      }
+      showSpread() {
+        const t = this.getSpread()[this.currentSpreadIndex];
+        t.length === 2 ? (this.render.setLeftPage(this.pages[t[0]]), this.render.setRightPage(this.pages[t[1]])) : this.render.getOrientation() === "landscape" && t[0] === this.pages.length - 1 ? (this.render.setLeftPage(this.pages[t[0]]), this.render.setRightPage(null)) : (this.render.setLeftPage(null), this.render.setRightPage(this.pages[t[0]])), this.currentPageIndex = t[0], this.app.updatePageIndex(this.currentPageIndex);
+      }
+    }
+    class y extends f {
+      constructor(t, e, i) {
+        super(t, e), this.imagesHref = i;
+      }
+      load() {
+        for (const t of this.imagesHref) {
+          const e = new T(this.render, t, "soft");
+          e.load(), this.pages.push(e);
+        }
+        this.createSpread();
+      }
+    }
+    class l {
+      static GetDistanceBetweenTwoPoint(t, e) {
+        return t === null || e === null ? 1 / 0 : Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2));
+      }
+      static GetSegmentLength(t) {
+        return l.GetDistanceBetweenTwoPoint(t[0], t[1]);
+      }
+      static GetAngleBetweenTwoLine(t, e) {
+        const i = t[0].y - t[1].y, s = e[0].y - e[1].y, n = t[1].x - t[0].x, h = e[1].x - e[0].x;
+        return Math.acos((i * s + n * h) / (Math.sqrt(i * i + n * n) * Math.sqrt(s * s + h * h)));
+      }
+      static PointInRect(t, e) {
+        return e === null ? null : e.x >= t.left && e.x <= t.width + t.left && e.y >= t.top && e.y <= t.top + t.height ? e : null;
+      }
+      static GetRotatedPoint(t, e, i) {
+        return {
+          x: t.x * Math.cos(i) + t.y * Math.sin(i) + e.x,
+          y: t.y * Math.cos(i) - t.x * Math.sin(i) + e.y
+        };
+      }
+      static LimitPointToCircle(t, e, i) {
+        if (l.GetDistanceBetweenTwoPoint(t, i) <= e) return i;
+        const s = t.x, n = t.y, h = i.x, o = i.y;
+        let a = Math.sqrt(Math.pow(e, 2) * Math.pow(s - h, 2) / (Math.pow(s - h, 2) + Math.pow(n - o, 2))) + s;
+        i.x < 0 && (a *= -1);
+        let g = (a - s) * (n - o) / (s - h) + n;
+        return s - h + n === 0 && (g = e), {
+          x: a,
+          y: g
+        };
+      }
+      static GetIntersectBetweenTwoSegment(t, e, i) {
+        return l.PointInRect(t, l.GetIntersectBeetwenTwoLine(e, i));
+      }
+      static GetIntersectBeetwenTwoLine(t, e) {
+        const i = t[0].y - t[1].y, s = e[0].y - e[1].y, n = t[1].x - t[0].x, h = e[1].x - e[0].x, o = t[0].x * t[1].y - t[1].x * t[0].y, a = e[0].x * e[1].y - e[1].x * e[0].y, g = i * a - s * o, d = n * a - h * o, p = -(o * h - a * n) / (i * h - s * n), w = -(i * a - s * o) / (i * h - s * n);
+        if (isFinite(p) && isFinite(w)) return {
+          x: p,
+          y: w
+        };
+        if (Math.abs(g - d) < 0.1) throw new Error("Segment included");
+        return null;
+      }
+      static GetCordsFromTwoPoint(t, e) {
+        const i = Math.abs(t.x - e.x), s = Math.abs(t.y - e.y), n = Math.max(i, s), h = [t];
+        function o(a, g, d, p, w) {
+          return g > a ? a + w * (d / p) : g < a ? a - w * (d / p) : a;
+        }
+        for (let a = 1; a <= n; a += 1) h.push({
+          x: o(t.x, e.x, i, n, a),
+          y: o(t.y, e.y, s, n, a)
+        });
+        return h;
+      }
+    }
+    class x extends c {
+      constructor(t, e, i) {
+        super(t, i), this.copiedElement = null, this.temporaryCopy = null, this.isLoad = !1, this.element = e, this.element.classList.add("stf__item"), this.element.classList.add("--" + i);
+      }
+      newTemporaryCopy() {
+        return this.nowDrawingDensity === "hard" ? this : (this.temporaryCopy === null && (this.copiedElement = this.element.cloneNode(!0), this.element.parentElement.appendChild(this.copiedElement), this.temporaryCopy = new x(this.render, this.copiedElement, this.nowDrawingDensity)), this.getTemporaryCopy());
+      }
+      getTemporaryCopy() {
+        return this.temporaryCopy;
+      }
+      hideTemporaryCopy() {
+        this.temporaryCopy !== null && (this.copiedElement.remove(), this.copiedElement = null, this.temporaryCopy = null);
+      }
+      draw(t) {
+        const e = t || this.nowDrawingDensity, i = this.render.convertToGlobal(this.state.position), s = this.render.getRect().pageWidth, n = this.render.getRect().height;
+        this.element.classList.remove("--simple");
+        const h = `
+            display: block;
+            z-index: ${this.element.style.zIndex};
+            left: 0;
+            top: 0;
+            width: ${s}px;
+            height: ${n}px;
+        `;
+        e === "hard" ? this.drawHard(h) : this.drawSoft(i, h);
+      }
+      drawHard(t = "") {
+        const e = this.render.getRect().left + this.render.getRect().width / 2, i = this.state.hardDrawingAngle, s = t + `
+                backface-visibility: hidden;
+                -webkit-backface-visibility: hidden;
+                clip-path: none;
+                -webkit-clip-path: none;
+            ` + (this.orientation === 0 ? `transform-origin: ${this.render.getRect().pageWidth}px 0; 
+                   transform: translate3d(0, 0, 0) rotateY(${i}deg);` : `transform-origin: 0 0; 
+                   transform: translate3d(${e}px, 0, 0) rotateY(${i}deg);`);
+        this.element.style.cssText = s;
+      }
+      drawSoft(t, e = "") {
+        let i = "polygon( ";
+        for (const n of this.state.area) if (n !== null) {
+          let h = this.render.getDirection() === 1 ? {
+            x: -n.x + this.state.position.x,
+            y: n.y - this.state.position.y
+          } : {
+            x: n.x - this.state.position.x,
+            y: n.y - this.state.position.y
+          };
+          h = l.GetRotatedPoint(h, {
+            x: 0,
+            y: 0
+          }, this.state.angle), i += h.x + "px " + h.y + "px, ";
+        }
+        i = i.slice(0, -2), i += ")";
+        const s = e + `transform-origin: 0 0; clip-path: ${i}; -webkit-clip-path: ${i};` + (this.render.isSafari() && this.state.angle === 0 ? `transform: translate(${t.x}px, ${t.y}px);` : `transform: translate3d(${t.x}px, ${t.y}px, 0) rotate(${this.state.angle}rad);`);
+        this.element.style.cssText = s;
+      }
+      simpleDraw(t) {
+        const e = this.render.getRect(), i = e.pageWidth, s = e.height, n = t === 1 ? e.left + e.pageWidth : e.left, h = e.top;
+        this.element.classList.add("--simple"), this.element.style.cssText = `
+            position: absolute; 
+            display: block; 
+            height: ${s}px; 
+            left: ${n}px; 
+            top: ${h}px; 
+            width: ${i}px; 
+            z-index: ${this.render.getSettings().startZIndex + 1};`;
+      }
+      getElement() {
+        return this.element;
+      }
+      load() {
+        this.isLoad = !0;
+      }
+      setOrientation(t) {
+        super.setOrientation(t), this.element.classList.remove("--left", "--right"), this.element.classList.add(t === 1 ? "--right" : "--left");
+      }
+      setDrawingDensity(t) {
+        this.element.classList.remove("--soft", "--hard"), this.element.classList.add("--" + t), super.setDrawingDensity(t);
+      }
+    }
+    class P extends f {
+      constructor(t, e, i, s) {
+        super(t, e), this.element = i, this.pagesElement = s;
+      }
+      load() {
+        for (const t of this.pagesElement) {
+          const e = new x(this.render, t, t.dataset.density === "hard" ? "hard" : "soft");
+          e.load(), this.pages.push(e);
+        }
+        this.createSpread();
+      }
+    }
+    class C {
+      constructor(t, e, i, s) {
+        this.direction = t, this.corner = e, this.topIntersectPoint = null, this.sideIntersectPoint = null, this.bottomIntersectPoint = null, this.pageWidth = parseInt(i, 10), this.pageHeight = parseInt(s, 10);
+      }
+      calc(t) {
+        try {
+          return this.position = this.calcAngleAndPosition(t), this.calculateIntersectPoint(this.position), !0;
+        } catch {
+          return !1;
+        }
+      }
+      getFlippingClipArea() {
+        const t = [];
+        let e = !1;
+        return t.push(this.rect.topLeft), t.push(this.topIntersectPoint), this.sideIntersectPoint === null ? e = !0 : (t.push(this.sideIntersectPoint), this.bottomIntersectPoint === null && (e = !1)), t.push(this.bottomIntersectPoint), (e || this.corner === "bottom") && t.push(this.rect.bottomLeft), t;
+      }
+      getBottomClipArea() {
+        const t = [];
+        return t.push(this.topIntersectPoint), this.corner === "top" ? t.push({
+          x: this.pageWidth,
+          y: 0
+        }) : (this.topIntersectPoint !== null && t.push({
+          x: this.pageWidth,
+          y: 0
+        }), t.push({
+          x: this.pageWidth,
+          y: this.pageHeight
+        })), this.sideIntersectPoint !== null ? l.GetDistanceBetweenTwoPoint(this.sideIntersectPoint, this.topIntersectPoint) >= 10 && t.push(this.sideIntersectPoint) : this.corner === "top" && t.push({
+          x: this.pageWidth,
+          y: this.pageHeight
+        }), t.push(this.bottomIntersectPoint), t.push(this.topIntersectPoint), t;
+      }
+      getAngle() {
+        return this.direction === 0 ? -this.angle : this.angle;
+      }
+      getRect() {
+        return this.rect;
+      }
+      getPosition() {
+        return this.position;
+      }
+      getActiveCorner() {
+        return this.direction === 0 ? this.rect.topLeft : this.rect.topRight;
+      }
+      getDirection() {
+        return this.direction;
+      }
+      getFlippingProgress() {
+        return Math.abs((this.position.x - this.pageWidth) / (2 * this.pageWidth) * 100);
+      }
+      getCorner() {
+        return this.corner;
+      }
+      getBottomPagePosition() {
+        return this.direction === 1 ? {
+          x: this.pageWidth,
+          y: 0
+        } : {
+          x: 0,
+          y: 0
+        };
+      }
+      getShadowStartPoint() {
+        return this.corner === "top" ? this.topIntersectPoint : this.sideIntersectPoint !== null ? this.sideIntersectPoint : this.topIntersectPoint;
+      }
+      getShadowAngle() {
+        const t = l.GetAngleBetweenTwoLine(this.getSegmentToShadowLine(), [{
+          x: 0,
+          y: 0
+        }, {
+          x: this.pageWidth,
+          y: 0
+        }]);
+        return this.direction === 0 ? t : Math.PI - t;
+      }
+      calcAngleAndPosition(t) {
+        let e = t;
+        if (this.updateAngleAndGeometry(e), e = this.corner === "top" ? this.checkPositionAtCenterLine(e, {
+          x: 0,
+          y: 0
+        }, {
+          x: 0,
+          y: this.pageHeight
+        }) : this.checkPositionAtCenterLine(e, {
+          x: 0,
+          y: this.pageHeight
+        }, {
+          x: 0,
+          y: 0
+        }), Math.abs(e.x - this.pageWidth) < 1 && Math.abs(e.y) < 1) throw new Error("Point is too small");
+        return e;
+      }
+      updateAngleAndGeometry(t) {
+        this.angle = this.calculateAngle(t), this.rect = this.getPageRect(t);
+      }
+      calculateAngle(t) {
+        const e = this.pageWidth - t.x + 1, i = this.corner === "bottom" ? this.pageHeight - t.y : t.y;
+        let s = 2 * Math.acos(e / Math.sqrt(i * i + e * e));
+        i < 0 && (s = -s);
+        const n = Math.PI - s;
+        if (!isFinite(s) || n >= 0 && n < 3e-3) throw new Error("The G point is too small");
+        return this.corner === "bottom" && (s = -s), s;
+      }
+      getPageRect(t) {
+        return this.corner === "top" ? this.getRectFromBasePoint([
+          {
+            x: 0,
+            y: 0
+          },
+          {
+            x: this.pageWidth,
+            y: 0
+          },
+          {
+            x: 0,
+            y: this.pageHeight
+          },
+          {
+            x: this.pageWidth,
+            y: this.pageHeight
+          }
+        ], t) : this.getRectFromBasePoint([
+          {
+            x: 0,
+            y: -this.pageHeight
+          },
+          {
+            x: this.pageWidth,
+            y: -this.pageHeight
+          },
+          {
+            x: 0,
+            y: 0
+          },
+          {
+            x: this.pageWidth,
+            y: 0
+          }
+        ], t);
+      }
+      getRectFromBasePoint(t, e) {
+        return {
+          topLeft: this.getRotatedPoint(t[0], e),
+          topRight: this.getRotatedPoint(t[1], e),
+          bottomLeft: this.getRotatedPoint(t[2], e),
+          bottomRight: this.getRotatedPoint(t[3], e)
+        };
+      }
+      getRotatedPoint(t, e) {
+        return {
+          x: t.x * Math.cos(this.angle) + t.y * Math.sin(this.angle) + e.x,
+          y: t.y * Math.cos(this.angle) - t.x * Math.sin(this.angle) + e.y
+        };
+      }
+      calculateIntersectPoint(t) {
+        const e = {
+          left: -1,
+          top: -1,
+          width: this.pageWidth + 2,
+          height: this.pageHeight + 2
+        };
+        this.corner === "top" ? (this.topIntersectPoint = l.GetIntersectBetweenTwoSegment(e, [t, this.rect.topRight], [{
+          x: 0,
+          y: 0
+        }, {
+          x: this.pageWidth,
+          y: 0
+        }]), this.sideIntersectPoint = l.GetIntersectBetweenTwoSegment(e, [t, this.rect.bottomLeft], [{
+          x: this.pageWidth,
+          y: 0
+        }, {
+          x: this.pageWidth,
+          y: this.pageHeight
+        }]), this.bottomIntersectPoint = l.GetIntersectBetweenTwoSegment(e, [this.rect.bottomLeft, this.rect.bottomRight], [{
+          x: 0,
+          y: this.pageHeight
+        }, {
+          x: this.pageWidth,
+          y: this.pageHeight
+        }])) : (this.topIntersectPoint = l.GetIntersectBetweenTwoSegment(e, [this.rect.topLeft, this.rect.topRight], [{
+          x: 0,
+          y: 0
+        }, {
+          x: this.pageWidth,
+          y: 0
+        }]), this.sideIntersectPoint = l.GetIntersectBetweenTwoSegment(e, [t, this.rect.topLeft], [{
+          x: this.pageWidth,
+          y: 0
+        }, {
+          x: this.pageWidth,
+          y: this.pageHeight
+        }]), this.bottomIntersectPoint = l.GetIntersectBetweenTwoSegment(e, [this.rect.bottomLeft, this.rect.bottomRight], [{
+          x: 0,
+          y: this.pageHeight
+        }, {
+          x: this.pageWidth,
+          y: this.pageHeight
+        }]));
+      }
+      checkPositionAtCenterLine(t, e, i) {
+        let s = t;
+        const n = l.LimitPointToCircle(e, this.pageWidth, s);
+        s !== n && (s = n, this.updateAngleAndGeometry(s));
+        const h = Math.sqrt(Math.pow(this.pageWidth, 2) + Math.pow(this.pageHeight, 2));
+        let o = this.rect.bottomRight, a = this.rect.topLeft;
+        if (this.corner === "bottom" && (o = this.rect.topRight, a = this.rect.bottomLeft), o.x <= 0) {
+          const g = l.LimitPointToCircle(i, h, a);
+          g !== s && (s = g, this.updateAngleAndGeometry(s));
+        }
+        return s;
+      }
+      getSegmentToShadowLine() {
+        const t = this.getShadowStartPoint();
+        return [t, t !== this.sideIntersectPoint && this.sideIntersectPoint !== null ? this.sideIntersectPoint : this.bottomIntersectPoint];
+      }
+    }
+    class S {
+      constructor(t, e) {
+        this.flippingPage = null, this.bottomPage = null, this.calc = null, this.state = "read", this.render = t, this.app = e;
+      }
+      fold(t) {
+        this.setState("user_fold"), this.calc === null && this.start(t), this.do(this.render.convertToPage(t));
+      }
+      flip(t) {
+        if (this.app.getSettings().disableFlipByClick && !this.isPointOnCorners(t) || (this.calc !== null && this.render.finishAnimation(), !this.start(t))) return;
+        const e = this.getBoundsRect();
+        this.setState("flipping");
+        const i = e.height / 10, s = this.calc.getCorner() === "bottom" ? e.height - i : i, n = this.calc.getCorner() === "bottom" ? e.height : 0;
+        this.calc.calc({
+          x: e.pageWidth - i,
+          y: s
+        }), this.animateFlippingTo({
+          x: e.pageWidth - i,
+          y: s
+        }, {
+          x: -e.pageWidth,
+          y: n
+        }, !0);
+      }
+      start(t) {
+        this.reset();
+        const e = this.render.convertToBook(t), i = this.getBoundsRect(), s = this.getDirectionByPoint(e), n = e.y >= i.height / 2 ? "bottom" : "top";
+        if (!this.checkDirection(s)) return !1;
+        try {
+          if (this.flippingPage = this.app.getPageCollection().getFlippingPage(s), this.bottomPage = this.app.getPageCollection().getBottomPage(s), this.render.getOrientation() === "landscape") if (s === 1) {
+            const h = this.app.getPageCollection().nextBy(this.flippingPage);
+            h !== null && this.flippingPage.getDensity() !== h.getDensity() && (this.flippingPage.setDrawingDensity("hard"), h.setDrawingDensity("hard"));
+          } else {
+            const h = this.app.getPageCollection().prevBy(this.flippingPage);
+            h !== null && this.flippingPage.getDensity() !== h.getDensity() && (this.flippingPage.setDrawingDensity("hard"), h.setDrawingDensity("hard"));
+          }
+          return this.render.setDirection(s), this.calc = new C(s, n, i.pageWidth.toString(10), i.height.toString(10)), !0;
+        } catch {
+          return !1;
+        }
+      }
+      do(t) {
+        if (this.calc !== null && this.calc.calc(t)) {
+          const e = this.calc.getFlippingProgress();
+          this.bottomPage.setArea(this.calc.getBottomClipArea()), this.bottomPage.setPosition(this.calc.getBottomPagePosition()), this.bottomPage.setAngle(0), this.bottomPage.setHardAngle(0), this.flippingPage.setArea(this.calc.getFlippingClipArea()), this.flippingPage.setPosition(this.calc.getActiveCorner()), this.flippingPage.setAngle(this.calc.getAngle()), this.calc.getDirection() === 0 ? this.flippingPage.setHardAngle(90 * (200 - 2 * e) / 100) : this.flippingPage.setHardAngle(-90 * (200 - 2 * e) / 100), this.render.setPageRect(this.calc.getRect()), this.render.setBottomPage(this.bottomPage), this.render.setFlippingPage(this.flippingPage), this.render.setShadowData(this.calc.getShadowStartPoint(), this.calc.getShadowAngle(), e, this.calc.getDirection());
+        }
+      }
+      flipToPage(t, e) {
+        const i = this.app.getPageCollection().getCurrentSpreadIndex(), s = this.app.getPageCollection().getSpreadIndexByPage(t);
+        try {
+          s > i && (this.app.getPageCollection().setCurrentSpreadIndex(s - 1), this.flipNext(e)), s < i && (this.app.getPageCollection().setCurrentSpreadIndex(s + 1), this.flipPrev(e));
+        } catch {
+        }
+      }
+      flipNext(t) {
+        this.flip({
+          x: this.render.getRect().left + 2 * this.render.getRect().pageWidth - 10,
+          y: t === "top" ? 1 : this.render.getRect().height - 2
+        });
+      }
+      flipPrev(t) {
+        this.flip({
+          x: 10,
+          y: t === "top" ? 1 : this.render.getRect().height - 2
+        });
+      }
+      stopMove() {
+        if (this.calc === null) return;
+        const t = this.calc.getPosition(), e = this.getBoundsRect(), i = this.calc.getCorner() === "bottom" ? e.height : 0;
+        t.x <= 0 ? this.animateFlippingTo(t, {
+          x: -e.pageWidth,
+          y: i
+        }, !0) : this.animateFlippingTo(t, {
+          x: e.pageWidth,
+          y: i
+        }, !1);
+      }
+      showCorner(t) {
+        if (!this.checkState("read", "fold_corner")) return;
+        const e = this.getBoundsRect(), i = e.pageWidth;
+        if (this.isPointOnCorners(t)) if (this.calc === null) {
+          if (!this.start(t)) return;
+          this.setState("fold_corner"), this.calc.calc({
+            x: i - 1,
+            y: 1
+          });
+          const s = 50, n = this.calc.getCorner() === "bottom" ? e.height - 1 : 1, h = this.calc.getCorner() === "bottom" ? e.height - s : s;
+          this.animateFlippingTo({
+            x: i - 1,
+            y: n
+          }, {
+            x: i - s,
+            y: h
+          }, !1, !1);
+        } else this.do(this.render.convertToPage(t));
+        else this.setState("read"), this.render.finishAnimation(), this.stopMove();
+      }
+      animateFlippingTo(t, e, i, s = !0) {
+        const n = l.GetCordsFromTwoPoint(t, e), h = [];
+        for (const a of n) h.push(() => this.do(a));
+        const o = this.getAnimationDuration(n.length);
+        this.render.startAnimation(h, o, () => {
+          this.calc && (i && (this.calc.getDirection() === 1 ? this.app.turnToPrevPage() : this.app.turnToNextPage()), s && (this.render.setBottomPage(null), this.render.setFlippingPage(null), this.render.clearShadow(), this.setState("read"), this.reset()));
+        });
+      }
+      getCalculation() {
+        return this.calc;
+      }
+      getState() {
+        return this.state;
+      }
+      setState(t) {
+        this.state !== t && (this.app.updateState(t), this.state = t);
+      }
+      getDirectionByPoint(t) {
+        const e = this.getBoundsRect();
+        if (this.render.getOrientation() === "portrait") {
+          if (t.x - e.pageWidth <= e.width / 5) return 1;
+        } else if (t.x < e.width / 2) return 1;
+        return 0;
+      }
+      getAnimationDuration(t) {
+        const e = this.app.getSettings().flippingTime;
+        return t >= 1e3 ? e : t / 1e3 * e;
+      }
+      checkDirection(t) {
+        return t === 0 ? this.app.getCurrentPageIndex() < this.app.getPageCount() - 1 : this.app.getCurrentPageIndex() >= 1;
+      }
+      reset() {
+        this.calc = null, this.flippingPage = null, this.bottomPage = null;
+      }
+      getBoundsRect() {
+        return this.render.getRect();
+      }
+      checkState(...t) {
+        for (const e of t) if (this.state === e) return !0;
+        return !1;
+      }
+      isPointOnCorners(t) {
+        const e = this.getBoundsRect(), i = e.pageWidth, s = Math.sqrt(Math.pow(i, 2) + Math.pow(e.height, 2)) / 5, n = this.render.convertToBook(t);
+        return n.x > 0 && n.y > 0 && n.x < e.width && n.y < e.height && (n.x < s || n.x > e.width - s) && (n.y < s || n.y > e.height - s);
+      }
+    }
+    class b {
+      constructor(t, e) {
+        this.leftPage = null, this.rightPage = null, this.flippingPage = null, this.bottomPage = null, this.direction = null, this.orientation = null, this.shadow = null, this.animation = null, this.pageRect = null, this.boundsRect = null, this.timer = 0, this.safari = !1, this.setting = e, this.app = t, this.safari = (/* @__PURE__ */ new RegExp("Version\\/[\\d\\.]+.*Safari/")).exec(window.navigator.userAgent) !== null;
+      }
+      render(t) {
+        if (this.animation !== null) {
+          const e = Math.round((t - this.animation.startedAt) / this.animation.durationFrame);
+          e < this.animation.frames.length ? this.animation.frames[e]() : (this.animation.onAnimateEnd(), this.animation = null);
+        }
+        this.timer = t, this.drawFrame();
+      }
+      start() {
+        this.update();
+        const t = (e) => {
+          this.render(e), requestAnimationFrame(t);
+        };
+        requestAnimationFrame(t);
+      }
+      startAnimation(t, e, i) {
+        this.finishAnimation(), this.animation = {
+          frames: t,
+          duration: e,
+          durationFrame: e / t.length,
+          onAnimateEnd: i,
+          startedAt: this.timer
+        };
+      }
+      finishAnimation() {
+        this.animation !== null && (this.animation.frames[this.animation.frames.length - 1](), this.animation.onAnimateEnd !== null && this.animation.onAnimateEnd()), this.animation = null;
+      }
+      update() {
+        this.boundsRect = null;
+        const t = this.calculateBoundsRect();
+        this.orientation !== t && (this.orientation = t, this.app.updateOrientation(t));
+      }
+      calculateBoundsRect() {
+        let t = "landscape";
+        const e = this.getBlockWidth(), i = e / 2, s = this.getBlockHeight() / 2, n = this.setting.width / this.setting.height;
+        let h = this.setting.width, o = this.setting.height, a = i - h;
+        return this.setting.size === "stretch" ? (e < 2 * this.setting.minWidth && this.app.getSettings().usePortrait && (t = "portrait"), h = t === "portrait" ? this.getBlockWidth() : this.getBlockWidth() / 2, h > this.setting.maxWidth && (h = this.setting.maxWidth), o = h / n, o > this.getBlockHeight() && (o = this.getBlockHeight(), h = o * n), a = t === "portrait" ? i - h / 2 - h : i - h) : e < 2 * h && this.app.getSettings().usePortrait && (t = "portrait", a = i - h / 2 - h), this.boundsRect = {
+          left: a,
+          top: s - o / 2,
+          width: 2 * h,
+          height: o,
+          pageWidth: h
+        }, t;
+      }
+      setShadowData(t, e, i, s) {
+        if (!this.app.getSettings().drawShadow) return;
+        const n = 100 * this.getSettings().maxShadowOpacity;
+        this.shadow = {
+          pos: t,
+          angle: e,
+          width: 3 * this.getRect().pageWidth / 4 * i / 100,
+          opacity: (100 - i) * n / 100 / 100,
+          direction: s,
+          progress: 2 * i
+        };
+      }
+      clearShadow() {
+        this.shadow = null;
+      }
+      getBlockWidth() {
+        return this.app.getUI().getDistElement().offsetWidth;
+      }
+      getBlockHeight() {
+        return this.app.getUI().getDistElement().offsetHeight;
+      }
+      getDirection() {
+        return this.direction;
+      }
+      getRect() {
+        return this.boundsRect === null && this.calculateBoundsRect(), this.boundsRect;
+      }
+      getSettings() {
+        return this.app.getSettings();
+      }
+      getOrientation() {
+        return this.orientation;
+      }
+      setPageRect(t) {
+        this.pageRect = t;
+      }
+      setDirection(t) {
+        this.direction = t;
+      }
+      setRightPage(t) {
+        t !== null && t.setOrientation(1), this.rightPage = t;
+      }
+      setLeftPage(t) {
+        t !== null && t.setOrientation(0), this.leftPage = t;
+      }
+      setBottomPage(t) {
+        t !== null && t.setOrientation(this.direction === 1 ? 0 : 1), this.bottomPage = t;
+      }
+      setFlippingPage(t) {
+        t !== null && t.setOrientation(this.direction === 0 && this.orientation !== "portrait" ? 0 : 1), this.flippingPage = t;
+      }
+      convertToBook(t) {
+        const e = this.getRect();
+        return {
+          x: t.x - e.left,
+          y: t.y - e.top
+        };
+      }
+      isSafari() {
+        return this.safari;
+      }
+      convertToPage(t, e) {
+        e || (e = this.direction);
+        const i = this.getRect();
+        return {
+          x: e === 0 ? t.x - i.left - i.width / 2 : i.width / 2 - t.x + i.left,
+          y: t.y - i.top
+        };
+      }
+      convertToGlobal(t, e) {
+        if (e || (e = this.direction), t == null) return null;
+        const i = this.getRect();
+        return {
+          x: e === 0 ? t.x + i.left + i.width / 2 : i.width / 2 - t.x + i.left,
+          y: t.y + i.top
+        };
+      }
+      convertRectToGlobal(t, e) {
+        return e || (e = this.direction), {
+          topLeft: this.convertToGlobal(t.topLeft, e),
+          topRight: this.convertToGlobal(t.topRight, e),
+          bottomLeft: this.convertToGlobal(t.bottomLeft, e),
+          bottomRight: this.convertToGlobal(t.bottomRight, e)
+        };
+      }
+    }
+    class D extends b {
+      constructor(t, e, i) {
+        super(t, e), this.canvas = i, this.ctx = i.getContext("2d");
+      }
+      getContext() {
+        return this.ctx;
+      }
+      reload() {
+      }
+      drawFrame() {
+        this.clear(), this.orientation !== "portrait" && this.leftPage != null && this.leftPage.simpleDraw(0), this.rightPage != null && this.rightPage.simpleDraw(1), this.bottomPage != null && this.bottomPage.draw(), this.drawBookShadow(), this.flippingPage != null && this.flippingPage.draw(), this.shadow != null && (this.drawOuterShadow(), this.drawInnerShadow());
+        const t = this.getRect();
+        this.orientation === "portrait" && (this.ctx.beginPath(), this.ctx.rect(t.left + t.pageWidth, t.top, t.width, t.height), this.ctx.clip());
+      }
+      drawBookShadow() {
+        const t = this.getRect();
+        this.ctx.save(), this.ctx.beginPath();
+        const e = t.width / 20;
+        this.ctx.rect(t.left, t.top, t.width, t.height);
+        const i = {
+          x: t.left + t.width / 2 - e / 2,
+          y: 0
+        };
+        this.ctx.translate(i.x, i.y);
+        const s = this.ctx.createLinearGradient(0, 0, e, 0);
+        s.addColorStop(0, "rgba(0, 0, 0, 0)"), s.addColorStop(0.4, "rgba(0, 0, 0, 0.2)"), s.addColorStop(0.49, "rgba(0, 0, 0, 0.1)"), s.addColorStop(0.5, "rgba(0, 0, 0, 0.5)"), s.addColorStop(0.51, "rgba(0, 0, 0, 0.4)"), s.addColorStop(1, "rgba(0, 0, 0, 0)"), this.ctx.clip(), this.ctx.fillStyle = s, this.ctx.fillRect(0, 0, e, 2 * t.height), this.ctx.restore();
+      }
+      drawOuterShadow() {
+        const t = this.getRect();
+        this.ctx.save(), this.ctx.beginPath(), this.ctx.rect(t.left, t.top, t.width, t.height);
+        const e = this.convertToGlobal({
+          x: this.shadow.pos.x,
+          y: this.shadow.pos.y
+        });
+        this.ctx.translate(e.x, e.y), this.ctx.rotate(Math.PI + this.shadow.angle + Math.PI / 2);
+        const i = this.ctx.createLinearGradient(0, 0, this.shadow.width, 0);
+        this.shadow.direction === 0 ? (this.ctx.translate(0, -100), i.addColorStop(0, "rgba(0, 0, 0, " + this.shadow.opacity + ")"), i.addColorStop(1, "rgba(0, 0, 0, 0)")) : (this.ctx.translate(-this.shadow.width, -100), i.addColorStop(0, "rgba(0, 0, 0, 0)"), i.addColorStop(1, "rgba(0, 0, 0, " + this.shadow.opacity + ")")), this.ctx.clip(), this.ctx.fillStyle = i, this.ctx.fillRect(0, 0, this.shadow.width, 2 * t.height), this.ctx.restore();
+      }
+      drawInnerShadow() {
+        const t = this.getRect();
+        this.ctx.save(), this.ctx.beginPath();
+        const e = this.convertToGlobal({
+          x: this.shadow.pos.x,
+          y: this.shadow.pos.y
+        }), i = this.convertRectToGlobal(this.pageRect);
+        this.ctx.moveTo(i.topLeft.x, i.topLeft.y), this.ctx.lineTo(i.topRight.x, i.topRight.y), this.ctx.lineTo(i.bottomRight.x, i.bottomRight.y), this.ctx.lineTo(i.bottomLeft.x, i.bottomLeft.y), this.ctx.translate(e.x, e.y), this.ctx.rotate(Math.PI + this.shadow.angle + Math.PI / 2);
+        const s = 3 * this.shadow.width / 4, n = this.ctx.createLinearGradient(0, 0, s, 0);
+        this.shadow.direction === 0 ? (this.ctx.translate(-s, -100), n.addColorStop(1, "rgba(0, 0, 0, " + this.shadow.opacity + ")"), n.addColorStop(0.9, "rgba(0, 0, 0, 0.05)"), n.addColorStop(0.7, "rgba(0, 0, 0, " + this.shadow.opacity + ")"), n.addColorStop(0, "rgba(0, 0, 0, 0)")) : (this.ctx.translate(0, -100), n.addColorStop(0, "rgba(0, 0, 0, " + this.shadow.opacity + ")"), n.addColorStop(0.1, "rgba(0, 0, 0, 0.05)"), n.addColorStop(0.3, "rgba(0, 0, 0, " + this.shadow.opacity + ")"), n.addColorStop(1, "rgba(0, 0, 0, 0)")), this.ctx.clip(), this.ctx.fillStyle = n, this.ctx.fillRect(0, 0, s, 2 * t.height), this.ctx.restore();
+      }
+      clear() {
+        this.ctx.fillStyle = "white", this.ctx.fillRect(0, 0, this.canvas.width, this.canvas.height);
+      }
+    }
+    class v {
+      constructor(t, e, i) {
+        this.touchPoint = null, this.swipeTimeout = 250, this.onResize = () => {
+          this.update();
+        }, this.onMouseDown = (n) => {
+          if (this.checkTarget(n.target)) {
+            const h = this.getMousePos(n.clientX, n.clientY);
+            this.app.startUserTouch(h), n.preventDefault();
+          }
+        }, this.onTouchStart = (n) => {
+          if (this.checkTarget(n.target) && n.changedTouches.length > 0) {
+            const h = n.changedTouches[0], o = this.getMousePos(h.clientX, h.clientY);
+            this.touchPoint = {
+              point: o,
+              time: Date.now()
+            }, setTimeout(() => {
+              this.touchPoint !== null && this.app.startUserTouch(o);
+            }, this.swipeTimeout), this.app.getSettings().mobileScrollSupport || n.preventDefault();
+          }
+        }, this.onMouseUp = (n) => {
+          const h = this.getMousePos(n.clientX, n.clientY);
+          this.app.userStop(h);
+        }, this.onMouseMove = (n) => {
+          const h = this.getMousePos(n.clientX, n.clientY);
+          this.app.userMove(h, !1);
+        }, this.onTouchMove = (n) => {
+          if (n.changedTouches.length > 0) {
+            const h = n.changedTouches[0], o = this.getMousePos(h.clientX, h.clientY);
+            this.app.getSettings().mobileScrollSupport ? (this.touchPoint !== null && (Math.abs(this.touchPoint.point.x - o.x) > 10 || this.app.getState() !== "read") && n.cancelable && this.app.userMove(o, !0), this.app.getState() !== "read" && n.preventDefault()) : this.app.userMove(o, !0);
+          }
+        }, this.onTouchEnd = (n) => {
+          if (n.changedTouches.length > 0) {
+            const h = n.changedTouches[0], o = this.getMousePos(h.clientX, h.clientY);
+            let a = !1;
+            if (this.touchPoint !== null) {
+              const g = o.x - this.touchPoint.point.x, d = Math.abs(o.y - this.touchPoint.point.y);
+              Math.abs(g) > this.swipeDistance && d < 2 * this.swipeDistance && Date.now() - this.touchPoint.time < this.swipeTimeout && (g > 0 ? this.app.flipPrev(this.touchPoint.point.y < this.app.getRender().getRect().height / 2 ? "top" : "bottom") : this.app.flipNext(this.touchPoint.point.y < this.app.getRender().getRect().height / 2 ? "top" : "bottom"), a = !0), this.touchPoint = null;
+            }
+            this.app.userStop(o, a);
+          }
+        }, this.parentElement = t, t.classList.add("stf__parent"), t.insertAdjacentHTML("afterbegin", '<div class="stf__wrapper"></div>'), this.wrapper = t.querySelector(".stf__wrapper"), this.app = e;
+        const s = this.app.getSettings().usePortrait ? 1 : 2;
+        t.style.minWidth = i.minWidth * s + "px", t.style.minHeight = i.minHeight + "px", i.size === "fixed" && (t.style.minWidth = i.width * s + "px", t.style.minHeight = i.height + "px"), i.autoSize && (t.style.width = "100%", t.style.maxWidth = 2 * i.maxWidth + "px"), t.style.display = "block", window.addEventListener("resize", this.onResize, !1), this.swipeDistance = i.swipeDistance;
+      }
+      destroy() {
+        this.app.getSettings().useMouseEvents && this.removeHandlers(), this.distElement.remove(), this.wrapper.remove();
+      }
+      getDistElement() {
+        return this.distElement;
+      }
+      getWrapper() {
+        return this.wrapper;
+      }
+      setOrientationStyle(t) {
+        this.wrapper.classList.remove("--portrait", "--landscape"), t === "portrait" ? (this.app.getSettings().autoSize && (this.wrapper.style.paddingBottom = this.app.getSettings().height / this.app.getSettings().width * 100 + "%"), this.wrapper.classList.add("--portrait")) : (this.app.getSettings().autoSize && (this.wrapper.style.paddingBottom = this.app.getSettings().height / (2 * this.app.getSettings().width) * 100 + "%"), this.wrapper.classList.add("--landscape")), this.update();
+      }
+      removeHandlers() {
+        window.removeEventListener("resize", this.onResize), this.distElement.removeEventListener("mousedown", this.onMouseDown), this.distElement.removeEventListener("touchstart", this.onTouchStart), window.removeEventListener("mousemove", this.onMouseMove), window.removeEventListener("touchmove", this.onTouchMove), window.removeEventListener("mouseup", this.onMouseUp), window.removeEventListener("touchend", this.onTouchEnd);
+      }
+      setHandlers() {
+        window.addEventListener("resize", this.onResize, !1), this.app.getSettings().useMouseEvents && (this.distElement.addEventListener("mousedown", this.onMouseDown), this.distElement.addEventListener("touchstart", this.onTouchStart), window.addEventListener("mousemove", this.onMouseMove), window.addEventListener("touchmove", this.onTouchMove, { passive: !this.app.getSettings().mobileScrollSupport }), window.addEventListener("mouseup", this.onMouseUp), window.addEventListener("touchend", this.onTouchEnd));
+      }
+      getMousePos(t, e) {
+        const i = this.distElement.getBoundingClientRect();
+        return {
+          x: t - i.left,
+          y: e - i.top
+        };
+      }
+      checkTarget(t) {
+        return !this.app.getSettings().clickEventForward || !["a", "button"].includes(t.tagName.toLowerCase());
+      }
+    }
+    class R extends v {
+      constructor(t, e, i, s) {
+        super(t, e, i), this.wrapper.insertAdjacentHTML("afterbegin", '<div class="stf__block"></div>'), this.distElement = t.querySelector(".stf__block"), this.items = s;
+        for (const n of s) this.distElement.appendChild(n);
+        this.setHandlers();
+      }
+      clear() {
+        for (const t of this.items) this.parentElement.appendChild(t);
+      }
+      updateItems(t) {
+        this.removeHandlers(), this.distElement.innerHTML = "";
+        for (const e of t) this.distElement.appendChild(e);
+        this.items = t, this.setHandlers();
+      }
+      update() {
+        this.app.getRender().update();
+      }
+    }
+    class M extends v {
+      constructor(t, e, i) {
+        super(t, e, i), this.wrapper.innerHTML = '<canvas class="stf__canvas"></canvas>', this.canvas = t.querySelectorAll("canvas")[0], this.distElement = this.canvas, this.resizeCanvas(), this.setHandlers();
+      }
+      resizeCanvas() {
+        const t = getComputedStyle(this.canvas), e = parseInt(t.getPropertyValue("width"), 10), i = parseInt(t.getPropertyValue("height"), 10);
+        this.canvas.width = e, this.canvas.height = i;
+      }
+      getCanvas() {
+        return this.canvas;
+      }
+      update() {
+        this.resizeCanvas(), this.app.getRender().update();
+      }
+    }
+    class L extends b {
+      constructor(t, e, i) {
+        super(t, e), this.outerShadow = null, this.innerShadow = null, this.hardShadow = null, this.hardInnerShadow = null, this.element = i, this.createShadows();
+      }
+      createShadows() {
+        this.element.insertAdjacentHTML("beforeend", `<div class="stf__outerShadow"></div>
+             <div class="stf__innerShadow"></div>
+             <div class="stf__hardShadow"></div>
+             <div class="stf__hardInnerShadow"></div>`), this.outerShadow = this.element.querySelector(".stf__outerShadow"), this.innerShadow = this.element.querySelector(".stf__innerShadow"), this.hardShadow = this.element.querySelector(".stf__hardShadow"), this.hardInnerShadow = this.element.querySelector(".stf__hardInnerShadow");
+      }
+      clearShadow() {
+        super.clearShadow(), this.outerShadow.style.cssText = "display: none", this.innerShadow.style.cssText = "display: none", this.hardShadow.style.cssText = "display: none", this.hardInnerShadow.style.cssText = "display: none";
+      }
+      reload() {
+        this.element.querySelector(".stf__outerShadow") || this.createShadows();
+      }
+      drawHardInnerShadow() {
+        const t = this.getRect(), e = this.shadow.progress > 100 ? 200 - this.shadow.progress : this.shadow.progress;
+        let i = (100 - e) * (2.5 * t.pageWidth) / 100 + 20;
+        i > t.pageWidth && (i = t.pageWidth);
+        let s = `
+            display: block;
+            z-index: ${(this.getSettings().startZIndex + 5).toString(10)};
+            width: ${i}px;
+            height: ${t.height}px;
+            background: linear-gradient(to right,
+                rgba(0, 0, 0, ${this.shadow.opacity * e / 100}) 5%,
+                rgba(0, 0, 0, 0) 100%);
+            left: ${t.left + t.width / 2}px;
+            transform-origin: 0 0;
+        `;
+        s += this.getDirection() === 0 && this.shadow.progress > 100 || this.getDirection() === 1 && this.shadow.progress <= 100 ? "transform: translate3d(0, 0, 0);" : "transform: translate3d(0, 0, 0) rotateY(180deg);", this.hardInnerShadow.style.cssText = s;
+      }
+      drawHardOuterShadow() {
+        const t = this.getRect();
+        let e = (100 - (this.shadow.progress > 100 ? 200 - this.shadow.progress : this.shadow.progress)) * (2.5 * t.pageWidth) / 100 + 20;
+        e > t.pageWidth && (e = t.pageWidth);
+        let i = `
+            display: block;
+            z-index: ${(this.getSettings().startZIndex + 4).toString(10)};
+            width: ${e}px;
+            height: ${t.height}px;
+            background: linear-gradient(to left, rgba(0, 0, 0, ${this.shadow.opacity}) 5%, rgba(0, 0, 0, 0) 100%);
+            left: ${t.left + t.width / 2}px;
+            transform-origin: 0 0;
+        `;
+        i += this.getDirection() === 0 && this.shadow.progress > 100 || this.getDirection() === 1 && this.shadow.progress <= 100 ? "transform: translate3d(0, 0, 0) rotateY(180deg);" : "transform: translate3d(0, 0, 0);", this.hardShadow.style.cssText = i;
+      }
+      drawInnerShadow() {
+        const t = this.getRect(), e = 3 * this.shadow.width / 4, i = this.getDirection() === 0 ? e : 0, s = this.getDirection() === 0 ? "to left" : "to right", n = this.convertToGlobal(this.shadow.pos), h = this.shadow.angle + 3 * Math.PI / 2, o = [
+          this.pageRect.topLeft,
+          this.pageRect.topRight,
+          this.pageRect.bottomRight,
+          this.pageRect.bottomLeft
+        ];
+        let a = "polygon( ";
+        for (const d of o) {
+          let p = this.getDirection() === 1 ? {
+            x: -d.x + this.shadow.pos.x,
+            y: d.y - this.shadow.pos.y
+          } : {
+            x: d.x - this.shadow.pos.x,
+            y: d.y - this.shadow.pos.y
+          };
+          p = l.GetRotatedPoint(p, {
+            x: i,
+            y: 100
+          }, h), a += p.x + "px " + p.y + "px, ";
+        }
+        a = a.slice(0, -2), a += ")";
+        const g = `
+            display: block;
+            z-index: ${(this.getSettings().startZIndex + 10).toString(10)};
+            width: ${e}px;
+            height: ${2 * t.height}px;
+            background: linear-gradient(${s},
+                rgba(0, 0, 0, ${this.shadow.opacity}) 5%,
+                rgba(0, 0, 0, 0.05) 15%,
+                rgba(0, 0, 0, ${this.shadow.opacity}) 35%,
+                rgba(0, 0, 0, 0) 100%);
+            transform-origin: ${i}px 100px;
+            transform: translate3d(${n.x - i}px, ${n.y - 100}px, 0) rotate(${h}rad);
+            clip-path: ${a};
+            -webkit-clip-path: ${a};
+        `;
+        this.innerShadow.style.cssText = g;
+      }
+      drawOuterShadow() {
+        const t = this.getRect(), e = this.convertToGlobal({
+          x: this.shadow.pos.x,
+          y: this.shadow.pos.y
+        }), i = this.shadow.angle + 3 * Math.PI / 2, s = this.getDirection() === 1 ? this.shadow.width : 0, n = this.getDirection() === 0 ? "to right" : "to left", h = [
+          {
+            x: 0,
+            y: 0
+          },
+          {
+            x: t.pageWidth,
+            y: 0
+          },
+          {
+            x: t.pageWidth,
+            y: t.height
+          },
+          {
+            x: 0,
+            y: t.height
+          }
+        ];
+        let o = "polygon( ";
+        for (const g of h) if (g !== null) {
+          let d = this.getDirection() === 1 ? {
+            x: -g.x + this.shadow.pos.x,
+            y: g.y - this.shadow.pos.y
+          } : {
+            x: g.x - this.shadow.pos.x,
+            y: g.y - this.shadow.pos.y
+          };
+          d = l.GetRotatedPoint(d, {
+            x: s,
+            y: 100
+          }, i), o += d.x + "px " + d.y + "px, ";
+        }
+        o = o.slice(0, -2), o += ")";
+        const a = `
+            display: block;
+            z-index: ${(this.getSettings().startZIndex + 10).toString(10)};
+            width: ${this.shadow.width}px;
+            height: ${2 * t.height}px;
+            background: linear-gradient(${n}, rgba(0, 0, 0, ${this.shadow.opacity}), rgba(0, 0, 0, 0));
+            transform-origin: ${s}px 100px;
+            transform: translate3d(${e.x - s}px, ${e.y - 100}px, 0) rotate(${i}rad);
+            clip-path: ${o};
+            -webkit-clip-path: ${o};
+        `;
+        this.outerShadow.style.cssText = a;
+      }
+      drawLeftPage() {
+        this.orientation !== "portrait" && this.leftPage !== null && (this.direction === 1 && this.flippingPage !== null && this.flippingPage.getDrawingDensity() === "hard" ? (this.leftPage.getElement().style.zIndex = (this.getSettings().startZIndex + 5).toString(10), this.leftPage.setHardDrawingAngle(180 + this.flippingPage.getHardAngle()), this.leftPage.draw(this.flippingPage.getDrawingDensity())) : this.leftPage.simpleDraw(0));
+      }
+      drawRightPage() {
+        this.rightPage !== null && (this.direction === 0 && this.flippingPage !== null && this.flippingPage.getDrawingDensity() === "hard" ? (this.rightPage.getElement().style.zIndex = (this.getSettings().startZIndex + 5).toString(10), this.rightPage.setHardDrawingAngle(180 + this.flippingPage.getHardAngle()), this.rightPage.draw(this.flippingPage.getDrawingDensity())) : this.rightPage.simpleDraw(1));
+      }
+      drawBottomPage() {
+        if (this.bottomPage === null) return;
+        const t = this.flippingPage != null ? this.flippingPage.getDrawingDensity() : null;
+        this.orientation === "portrait" && this.direction === 1 || (this.bottomPage.getElement().style.zIndex = (this.getSettings().startZIndex + 3).toString(10), this.bottomPage.draw(t));
+      }
+      drawFrame() {
+        this.clear(), this.drawLeftPage(), this.drawRightPage(), this.drawBottomPage(), this.flippingPage != null && (this.flippingPage.getElement().style.zIndex = (this.getSettings().startZIndex + 5).toString(10), this.flippingPage.draw()), this.shadow != null && this.flippingPage !== null && (this.flippingPage.getDrawingDensity() === "soft" ? (this.drawOuterShadow(), this.drawInnerShadow()) : (this.drawHardOuterShadow(), this.drawHardInnerShadow()));
+      }
+      clear() {
+        for (const t of this.app.getPageCollection().getPages()) t !== this.leftPage && t !== this.rightPage && t !== this.flippingPage && t !== this.bottomPage && (t.getElement().style.cssText = "display: none"), t.getTemporaryCopy() !== this.flippingPage && t.hideTemporaryCopy();
+      }
+      update() {
+        super.update(), this.rightPage !== null && this.rightPage.setOrientation(1), this.leftPage !== null && this.leftPage.setOrientation(0);
+      }
+    }
+    class A {
+      constructor() {
+        this._default = {
+          startPage: 0,
+          size: "fixed",
+          width: 0,
+          height: 0,
+          minWidth: 0,
+          maxWidth: 0,
+          minHeight: 0,
+          maxHeight: 0,
+          drawShadow: !0,
+          flippingTime: 1e3,
+          usePortrait: !0,
+          startZIndex: 0,
+          autoSize: !0,
+          maxShadowOpacity: 1,
+          showCover: !1,
+          mobileScrollSupport: !0,
+          swipeDistance: 30,
+          clickEventForward: !0,
+          useMouseEvents: !0,
+          showPageCorners: !0,
+          disableFlipByClick: !1
+        };
+      }
+      getSettings(t) {
+        const e = this._default;
+        if (Object.assign(e, t), e.size !== "stretch" && e.size !== "fixed") throw new Error('Invalid size type. Available only "fixed" and "stretch" value');
+        if (e.width <= 0 || e.height <= 0) throw new Error("Invalid width or height");
+        if (e.flippingTime <= 0) throw new Error("Invalid flipping time");
+        return e.size === "stretch" ? (e.minWidth <= 0 && (e.minWidth = 100), e.maxWidth < e.minWidth && (e.maxWidth = 2e3), e.minHeight <= 0 && (e.minHeight = 100), e.maxHeight < e.minHeight && (e.maxHeight = 2e3)) : (e.minWidth = e.width, e.maxWidth = e.width, e.minHeight = e.height, e.maxHeight = e.height), e;
+      }
+    }
+    (function(r, t) {
+      t === void 0 && (t = {});
+      var e = t.insertAt;
+      if (r && typeof document < "u") {
+        var i = document.head || document.getElementsByTagName("head")[0], s = document.createElement("style");
+        s.type = "text/css", e === "top" && i.firstChild ? i.insertBefore(s, i.firstChild) : i.appendChild(s), s.styleSheet ? s.styleSheet.cssText = r : s.appendChild(document.createTextNode(r));
+      }
+    })(`.stf__parent {
+  position: relative;
+  display: block;
+  box-sizing: border-box;
+  transform: translateZ(0);
+
+  -ms-touch-action: pan-y;
+  touch-action: pan-y;
+}
+
+.sft__wrapper {
+  position: relative;
+  width: 100%;
+  box-sizing: border-box;
+}
+
+.stf__parent canvas {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  left: 0;
+  top: 0;
+}
+
+.stf__block {
+  position: absolute;
+  width: 100%;
+  height: 100%;
+  box-sizing: border-box;
+  perspective: 2000px;
+}
+
+.stf__item {
+  display: none;
+  position: absolute;
+  transform-style: preserve-3d;
+}
+
+.stf__outerShadow {
+  position: absolute;
+  left: 0;
+  top: 0;
+}
+
+.stf__innerShadow {
+  position: absolute;
+  left: 0;
+  top: 0;
+}
+
+.stf__hardShadow {
+  position: absolute;
+  left: 0;
+  top: 0;
+}
+
+.stf__hardInnerShadow {
+  position: absolute;
+  left: 0;
+  top: 0;
+}`), u.PageFlip = class extends class {
+      constructor() {
+        this.events = /* @__PURE__ */ new Map();
+      }
+      on(r, t) {
+        return this.events.has(r) ? this.events.get(r).push(t) : this.events.set(r, [t]), this;
+      }
+      off(r) {
+        this.events.delete(r);
+      }
+      trigger(r, t, e = null) {
+        if (this.events.has(r)) for (const i of this.events.get(r)) i({
+          data: e,
+          object: t
+        });
+      }
+    } {
+      constructor(r, t) {
+        super(), this.isUserTouch = !1, this.isUserMove = !1, this.setting = null, this.pages = null, this.setting = new A().getSettings(t), this.block = r;
+      }
+      destroy() {
+        this.ui.destroy(), this.block.remove();
+      }
+      update() {
+        this.render.update(), this.pages.show();
+      }
+      loadFromImages(r) {
+        this.ui = new M(this.block, this, this.setting);
+        const t = this.ui.getCanvas();
+        this.render = new D(this, this.setting, t), this.flipController = new S(this.render, this), this.pages = new y(this, this.render, r), this.pages.load(), this.render.start(), this.pages.show(this.setting.startPage), setTimeout(() => {
+          this.ui.update(), this.trigger("init", this, {
+            page: this.setting.startPage,
+            mode: this.render.getOrientation()
+          });
+        }, 1);
+      }
+      loadFromHTML(r) {
+        this.ui = new R(this.block, this, this.setting, r), this.render = new L(this, this.setting, this.ui.getDistElement()), this.flipController = new S(this.render, this), this.pages = new P(this, this.render, this.ui.getDistElement(), r), this.pages.load(), this.render.start(), this.pages.show(this.setting.startPage), setTimeout(() => {
+          this.ui.update(), this.trigger("init", this, {
+            page: this.setting.startPage,
+            mode: this.render.getOrientation()
+          });
+        }, 1);
+      }
+      updateFromImages(r) {
+        const t = this.pages.getCurrentPageIndex();
+        this.pages.destroy(), this.pages = new y(this, this.render, r), this.pages.load(), this.pages.show(t), this.trigger("update", this, {
+          page: t,
+          mode: this.render.getOrientation()
+        });
+      }
+      updateFromHtml(r) {
+        const t = this.pages.getCurrentPageIndex();
+        this.pages.destroy(), this.pages = new P(this, this.render, this.ui.getDistElement(), r), this.pages.load(), this.ui.updateItems(r), this.render.reload(), this.pages.show(t), this.trigger("update", this, {
+          page: t,
+          mode: this.render.getOrientation()
+        });
+      }
+      clear() {
+        this.pages.destroy(), this.ui.clear();
+      }
+      turnToPrevPage() {
+        this.pages.showPrev();
+      }
+      turnToNextPage() {
+        this.pages.showNext();
+      }
+      turnToPage(r) {
+        this.pages.show(r);
+      }
+      flipNext(r = "top") {
+        this.flipController.flipNext(r);
+      }
+      flipPrev(r = "top") {
+        this.flipController.flipPrev(r);
+      }
+      flip(r, t = "top") {
+        this.flipController.flipToPage(r, t);
+      }
+      updateState(r) {
+        this.trigger("changeState", this, r);
+      }
+      updatePageIndex(r) {
+        this.trigger("flip", this, r);
+      }
+      updateOrientation(r) {
+        this.ui.setOrientationStyle(r), this.update(), this.trigger("changeOrientation", this, r);
+      }
+      getPageCount() {
+        return this.pages.getPageCount();
+      }
+      getCurrentPageIndex() {
+        return this.pages.getCurrentPageIndex();
+      }
+      getPage(r) {
+        return this.pages.getPage(r);
+      }
+      getRender() {
+        return this.render;
+      }
+      getFlipController() {
+        return this.flipController;
+      }
+      getOrientation() {
+        return this.render.getOrientation();
+      }
+      getBoundsRect() {
+        return this.render.getRect();
+      }
+      getSettings() {
+        return this.setting;
+      }
+      getUI() {
+        return this.ui;
+      }
+      getState() {
+        return this.flipController.getState();
+      }
+      getPageCollection() {
+        return this.pages;
+      }
+      startUserTouch(r) {
+        this.mousePosition = r, this.isUserTouch = !0, this.isUserMove = !1;
+      }
+      userMove(r, t) {
+        this.isUserTouch || t || !this.setting.showPageCorners ? this.isUserTouch && l.GetDistanceBetweenTwoPoint(this.mousePosition, r) > 5 && (this.isUserMove = !0, this.flipController.fold(r)) : this.flipController.showCorner(r);
+      }
+      userStop(r, t = !1) {
+        this.isUserTouch && (this.isUserTouch = !1, t || (this.isUserMove ? this.flipController.stopMove() : this.flipController.flip(r)));
+      }
+    }, Object.defineProperty(u, "__esModule", { value: !0 });
+  }));
+})), H = E();
+export {
+  H as default
+};