@objectifthunes/react-three-book 0.1.0

package/dist/index.js

@@ -0,0 +1,2880 @@
+import { jsxs as se, jsx as ie } from "react/jsx-runtime";
+import { useRef as ut, useState as $t, useEffect as Tt, createContext as ne, useContext as Yt, forwardRef as re, useImperativeHandle as oe, useCallback as rt, useMemo as ae } from "react";
+import { useFrame as Kt, useThree as he } from "@react-three/fiber";
+import * as c from "three";
+class pt {
+  constructor() {
+    this.m_PositionX = 0, this.m_PositionZ = 0, this.m_DirectionX = 0, this.m_DirectionZ = 0, this.m_EulerY = 0, this.m_Radius = 0;
+  }
+  // ── Properties ────────────────────────────────────────────────────────
+  get position() {
+    return new c.Vector3(this.m_PositionX, 0, this.m_PositionZ);
+  }
+  set position(t) {
+    this.m_PositionX = t.x, this.m_PositionZ = t.z;
+  }
+  set direction(t) {
+    this.m_DirectionX = t.x, this.m_DirectionZ = t.z, this.m_EulerY = Math.atan2(this.m_DirectionX, this.m_DirectionZ) * (180 / Math.PI);
+  }
+  set radius(t) {
+    this.m_Radius = t;
+  }
+  // ── Public API ────────────────────────────────────────────────────────
+  rollPoint(t) {
+    return this.roll(t.clone()).sub(this.getOffset(t.clone()));
+  }
+  // ── Private helpers ───────────────────────────────────────────────────
+  /**
+   * Apply Quaternion.Euler(0, eulerY, z) * Vector3(x, 0, 0) manually.
+   *
+   * Unity Euler convention (ZXY intrinsic, i.e. applied Z then X then Y):
+   *   1. Rotate (x, 0, 0) by Z degrees around Z-axis.
+   *   2. Rotate by X degrees around X-axis (X = 0 here, so skip).
+   *   3. Rotate by Y degrees around Y-axis.
+   */
+  eulerRotateVector(t, e, s) {
+    const i = s * Math.PI / 180, r = e * Math.PI / 180, o = Math.cos(i), a = Math.sin(i), h = t * o, u = t * a, l = 0, d = Math.cos(r), p = Math.sin(r), g = h * d + l * p, m = u, _ = -h * p + l * d;
+    return new c.Vector3(g, m, _);
+  }
+  roll(t) {
+    if (this.getSide(t) >= 0) return t;
+    const e = this.getClosestPoint(t.clone());
+    let s = t.distanceTo(e);
+    if (s > Math.PI * this.m_Radius) {
+      s = s - Math.PI * this.m_Radius;
+      const i = this.eulerRotateVector(-s, this.m_EulerY, 0);
+      t.copy(i.add(e)), t.y += this.m_Radius * 2;
+    } else {
+      const i = 180 / Math.PI * (s / this.m_Radius) - 90, r = this.eulerRotateVector(this.m_Radius, this.m_EulerY, i);
+      t.copy(r.add(e)), t.y += this.m_Radius;
+    }
+    return t;
+  }
+  getOffset(t) {
+    t.x = 0;
+    const e = this.roll(t.clone());
+    return e.z -= t.z, e;
+  }
+  getClosestPoint(t) {
+    const e = t.x - this.m_PositionX, s = t.z - this.m_PositionZ, i = e * this.m_DirectionX + s * this.m_DirectionZ;
+    return t.x = this.m_PositionX + this.m_DirectionX * i, t.z = this.m_PositionZ + this.m_DirectionZ * i, t;
+  }
+  getSide(t) {
+    const e = t.x - this.m_PositionX;
+    return (t.z - this.m_PositionZ) * this.m_DirectionX - e * this.m_DirectionZ;
+  }
+  // ── Value-type clone ──────────────────────────────────────────────────
+  clone() {
+    const t = new pt();
+    return t.m_PositionX = this.m_PositionX, t.m_PositionZ = this.m_PositionZ, t.m_DirectionX = this.m_DirectionX, t.m_DirectionZ = this.m_DirectionZ, t.m_EulerY = this.m_EulerY, t.m_Radius = this.m_Radius, t;
+  }
+}
+function Pt(n, t, e, s, i = 1 / 0, r = 1 / 60) {
+  s = Math.max(s, 1e-4);
+  const o = 2 / s, a = o * r, h = 1 / (1 + a + 0.48 * a * a + 0.235 * a * a * a);
+  let u = n - t;
+  const l = t, d = i * s;
+  u = c.MathUtils.clamp(u, -d, d), t = n - u;
+  const p = (e + o * u) * r;
+  e = (e - o * p) * h;
+  let g = t + (u + p) * h;
+  return l - n > 0 == g > l && (g = l, e = (g - l) / r), { value: g, velocity: e };
+}
+function le(n, t, e, s, i = 1 / 0, r = 1 / 60) {
+  const o = Pt(
+    n.x,
+    t.x,
+    e.x,
+    s.x,
+    i,
+    r
+  ), a = Pt(
+    n.y,
+    t.y,
+    e.y,
+    s.y,
+    i,
+    r
+  ), h = Pt(
+    n.z,
+    t.z,
+    e.z,
+    s.z,
+    i,
+    r
+  );
+  return e.set(o.velocity, a.velocity, h.velocity), new c.Vector3(o.value, a.value, h.value);
+}
+function ce(n) {
+  return new c.Vector3(n.x, 0, n.y);
+}
+function ue(n) {
+  return new c.Vector3(n.x, n.z, 0);
+}
+function Bt(n, t, e) {
+  const s = t * t - 4 * n * e;
+  if (s < 0)
+    return { rootCount: 0, root0: 0, root1: 0 };
+  if (s === 0)
+    return { rootCount: 1, root0: -t / 2 * n, root1: 0 };
+  {
+    const i = Math.sqrt(s);
+    return {
+      rootCount: 2,
+      root0: (-t + i) / (2 * n),
+      root1: (-t - i) / (2 * n)
+    };
+  }
+}
+function bt(n, t, e) {
+  return me(n, t, e) ? n.clone() : de(
+    new c.Vector2(n.x, t.y),
+    n,
+    t,
+    e
+  );
+}
+function me(n, t, e) {
+  const s = n.x - t.x;
+  let i = n.y - t.y;
+  return i *= e.x / e.y, Math.sqrt(s * s + i * i) < e.x;
+}
+function de(n, t, e, s) {
+  const i = e.x, r = e.y, o = n.x, a = n.y, h = t.x, u = t.y, l = s.x, d = s.y, p = 1 / (l * l), g = 1 / (d * d);
+  if (Math.abs(o - h) < 1e-5) {
+    if (o >= i - l && o <= i + l) {
+      const m = Bt(
+        g,
+        -2 * g * r,
+        p * (o * o - 2 * i * o + i * i) + g * r * r - 1
+      );
+      if (m.rootCount === 1)
+        return new c.Vector2(o, m.root0);
+      if (m.rootCount === 2) {
+        let _ = m.root0, f = m.root1;
+        return a < u && ([_, f] = [f, _]), new c.Vector2(o, f);
+      }
+    }
+  } else {
+    const m = (u - a) / (h - o), _ = a - m * o, f = _ - r, T = Bt(
+      p + g * m * m,
+      2 * f * m * g - 2 * i * p,
+      i * i * p + f * f * g - 1
+    );
+    if (T.rootCount === 1)
+      return new c.Vector2(T.root0, m * T.root0 + _);
+    if (T.rootCount === 2) {
+      let b = T.root0, x = T.root1;
+      return o < h && ([b, x] = [x, b]), new c.Vector2(x, m * x + _);
+    }
+  }
+  return n.clone();
+}
+function It(n, t) {
+  const e = n.origin.clone().applyMatrix4(t), s = n.origin.clone().add(n.direction).applyMatrix4(t);
+  return new c.Ray(e, s.sub(e));
+}
+function _e(n) {
+  return new c.Vector4(-n.x, n.y, n.z + n.x, n.w);
+}
+function ge(n) {
+  return new c.Vector4(n.x, -n.y, n.z, n.w + n.y);
+}
+var X = /* @__PURE__ */ ((n) => (n[n.LeftToRight = 0] = "LeftToRight", n[n.RightToLeft = 1] = "RightToLeft", n[n.UpToDown = 2] = "UpToDown", n[n.DownToUp = 3] = "DownToUp", n))(X || {});
+const Rt = Math.PI / 180, Vt = 180 / Math.PI, pe = 1192093e-13;
+function ft(n) {
+  return n < 0 ? 0 : n > 1 ? 1 : n;
+}
+function zt(n, t, e) {
+  return n < t ? t : n > e ? e : n;
+}
+function gt(n, t, e) {
+  return n !== t ? ft((e - n) / (t - n)) : 0;
+}
+function Dt(n, t, e) {
+  return n + (t - n) * e;
+}
+function At(n, t, e) {
+  return n + (t - n) * e;
+}
+function Ft(n, t, e) {
+  return e = ft((e - n) / (t - n)), e * e * (3 - 2 * e);
+}
+class fe {
+  // ---- Constructor ----
+  constructor(t, e, s, i) {
+    this.m_UseBackContentForSides = !1, this.m_Prev = null, this.m_Next = null, this.m_NoHole = !1, this.m_Size = new c.Vector2(), this.m_Thickness = 0, this.m_Stiffness = 0, this.m_Margin = 0, this.m_MeshDataType = 1, this.m_Cylinder = new pt(), this.m_IsRolling = !1, this.m_IsAutoTurning = !1, this.m_WorldPlane = new c.Plane(), this.m_StartHandle = new c.Vector3(), this.m_CurrentHandle = new c.Vector3(), this.m_EndHandle = new c.Vector3(), this.m_PrevHandle = new c.Vector3(), this.m_HandleOffset = new c.Vector3(), this.m_HandleVelocity = new c.Vector3(), this.m_HandleVelocities = [], this.m_SubMeshCount = -1, this.m_MinTurningRadius = 0, this.m_TurningRadius = 0, this.m_FallDuration = 0, this.m_FallTime = 0.2, this.m_XTime = 0, this.m_ZTime = 0, this.m_IsTurning = !1, this.m_IsFalling = !1, this.m_IsFallingLeft = !1, this.m_isMeshChanged = !1, this.sizeXOffset = 0, this.m_IsCover = t, this.m_Book = s, this.m_Index = e, this.m_Renderer = i, this.m_Transform = i.transform;
+  }
+  // ---- Properties (mirrors C#) ----
+  get isMeshChanged() {
+    return this.m_isMeshChanged;
+  }
+  set isMeshChanged(t) {
+    this.m_isMeshChanged = t;
+  }
+  get isCover() {
+    return this.m_IsCover;
+  }
+  get index() {
+    return this.m_Index;
+  }
+  get transform() {
+    return this.m_Transform;
+  }
+  get renderer() {
+    return this.m_Renderer;
+  }
+  get meshData() {
+    return this.m_MeshData;
+  }
+  get size() {
+    return this.m_Size;
+  }
+  set size(t) {
+    this.m_Size.copy(t);
+  }
+  get thickness() {
+    return this.m_Thickness;
+  }
+  get margin() {
+    return this.m_Margin;
+  }
+  get zTime() {
+    return this.m_IsFalling || this.m_IsTurning ? this.m_Transform.scale.x === -1 ? 1 - this.m_ZTime : this.m_ZTime : this.m_Transform.scale.x === -1 ? 1 : 0;
+  }
+  get direction() {
+    const e = this.zTime * 180 * Rt, s = Math.cos(e), i = Math.sin(e);
+    return new c.Vector3(-s, -i, 0);
+  }
+  get isTurning() {
+    return this.m_IsTurning;
+  }
+  get isFalling() {
+    return this.m_IsFalling;
+  }
+  get isFlipped() {
+    return this.m_Transform.scale.x === -1;
+  }
+  get isOnRightStack() {
+    return this.m_IsFalling ? this.m_Transform.scale.x === -1 ? this.m_IsFallingLeft : !this.m_IsFallingLeft : this.m_Transform.scale.x !== -1;
+  }
+  get frontContent() {
+    return this.m_FrontContent;
+  }
+  get backContent() {
+    return this.m_BackContent;
+  }
+  get currentContent() {
+    return this.isOnRightStack ? this.m_FrontContent : this.m_BackContent;
+  }
+  get needHole() {
+    if (this.m_NoHole || this.m_Prev === null || this.m_Next === null || this.m_IsTurning || this.m_IsAutoTurning || this.m_IsFalling || this.m_Prev.isCover || this.m_Next.isCover) return !1;
+    const t = this.m_Prev.isOnRightStack, e = this.isOnRightStack, s = this.m_Next.isOnRightStack;
+    return t === e && e === s;
+  }
+  set prev(t) {
+    this.m_Prev = t;
+  }
+  set next(t) {
+    this.m_Next = t;
+  }
+  set noHole(t) {
+    this.m_NoHole = t;
+  }
+  get isIdle() {
+    return !this.m_IsFalling && !this.m_IsTurning;
+  }
+  get isInMiddelOfStack() {
+    return this.m_Prev === null || this.m_Next === null ? !1 : this.isIdle && this.m_Prev.isIdle && this.m_Next.isIdle && this.m_Prev.isOnRightStack === this.m_Next.isOnRightStack;
+  }
+  // ---- Methods (faithful port, same order as C#) ----
+  setTime(t) {
+    this.m_XTime = t, this.m_ZTime = t;
+  }
+  setMeshData(t, e, s) {
+    this.m_MeshDataType = this.needHole && e != null ? 2 : 1, this.m_MeshData = this.m_MeshDataType === 2 ? e : t, this.m_LowpolyMeshData = t, this.m_LowpolyHoleMeshData = e, this.m_HighpolyMeshDataPool = s, this.m_Renderer.mesh = this.m_MeshData.geometry, this.m_Renderer.castShadows = this.m_Book.castShadows && !this.m_Book.reduceShadows, this.updateMaterials(), this.m_isMeshChanged = !0;
+  }
+  restState(t) {
+    this.m_IsTurning = !1, this.m_IsFalling = !1, this.m_IsAutoTurning = !1, this.m_Transform.scale.set(t ? 1 : -1, 1, 1), this.m_Book.bound.resetPaperPosition(this);
+  }
+  restMesh() {
+    this.switchMeshData(
+      this.needHole ? 2 : 1
+      /* Lowpoly */
+    ), this.updateMaterials();
+  }
+  setMaterialData(t) {
+    this.m_MaterialData = t;
+  }
+  setPaperSetup(t) {
+    this.m_Size.set(t.size.x, t.size.y), this.m_Thickness = t.thickness, this.m_Stiffness = t.stiffness, this.m_Margin = t.margin, this.m_UVMargin = t.uvMargin;
+  }
+  setContentData(t, e, s = !1) {
+    this.m_FrontContent = t, this.m_BackContent = e, this.m_UseBackContentForSides = s;
+  }
+  setMinTurningRadius(t) {
+    this.m_MinTurningRadius = t;
+  }
+  updateTurningRadius(t = 1) {
+    let e = Math.max(this.m_Stiffness, 1 - ft(t));
+    e <= 0.5 ? this.m_TurningRadius = gt(0, 0.5, e) * this.m_Size.x / Math.PI : this.m_TurningRadius = this.m_Size.x / (Math.max(180 * (1 - gt(0.5, 1, e)), 5) * Rt), this.m_TurningRadius = Math.max(
+      this.m_TurningRadius,
+      this.m_MinTurningRadius
+    );
+  }
+  startTurning(t) {
+    var r, o;
+    const e = t.clone();
+    t = It(
+      t,
+      this.m_Transform.matrixWorld.clone().invert()
+    ), this.m_WorldPlane.setFromNormalAndCoplanarPoint(
+      new c.Vector3(0, 1, 0).applyQuaternion(this.m_Transform.quaternion),
+      this.m_Transform.position
+    );
+    const s = new c.Plane(new c.Vector3(0, 1, 0), 0), i = new c.Vector3();
+    if (t.intersectPlane(s, i) !== null) {
+      const a = i;
+      if (a.x > 0 && a.x < this.m_Size.x && a.z > 0 && a.z < this.m_Size.y) {
+        if (this.m_IsRolling = !0, this.m_IsTurning = !0, this.m_IsFalling = !1, this.m_HandleOffset.set(0, 0, 0), this.m_StartHandle.copy(a), this.m_StartHandle.x = this.m_Size.x, this.m_CurrentHandle.copy(this.m_StartHandle), a.x < this.m_Size.x * 0.9) {
+          this.m_HandleOffset.set(a.x - this.m_Size.x, 0, 0);
+          const h = this.m_Transform.scale;
+          h.x *= -1;
+        }
+        return this.m_HandleVelocity.set(0, 0, 0), this.m_PrevHandle.copy(this.m_CurrentHandle), this.m_HandleVelocities.length = 0, this.switchMeshData(
+          0
+          /* Highpoly */
+        ), (r = this.m_Prev) == null || r.trySwitchMeshData(1), (o = this.m_Next) == null || o.trySwitchMeshData(1), this.updateTurning(e), this.clampHandle(), this.updateCylinder(), !0;
+      }
+    }
+    return !1;
+  }
+  stopTurning() {
+    this.clampHandle(), this.m_IsTurning = !1, this.m_IsFalling = !0;
+    const t = new c.Vector3(0, 0, 0);
+    for (const e of this.m_HandleVelocities)
+      t.add(e);
+    t.divideScalar(this.m_HandleVelocities.length), t.length() > 0.1 ? this.m_IsFallingLeft = t.x < 0 : this.m_IsFallingLeft = this.m_XTime > 0.5 && this.m_ZTime > 0.1, this.m_IsFallingLeft ? this.m_FallTime = 1 - this.m_XTime : this.m_FallTime = this.m_XTime, this.m_FallTime = Dt(0.1, 0.2, this.m_FallTime), this.m_EndHandle.copy(this.m_StartHandle), this.m_IsFallingLeft && (this.m_EndHandle.x = -this.m_Size.x);
+  }
+  /**
+   * Called each frame while the user is dragging.
+   * `dt` replaces Time.deltaTime.
+   */
+  updateTurning(t, e = 1 / 60) {
+    const s = new c.Vector3();
+    if (t.intersectPlane(this.m_WorldPlane, s) !== null) {
+      const i = s;
+      this.m_Book.bound.resetPaperPosition(this), this.m_CurrentHandle.copy(
+        this.m_Transform.worldToLocal(i.clone())
+      ), this.m_CurrentHandle.y = 0, this.m_CurrentHandle.add(this.m_HandleOffset), this.m_HandleVelocity.copy(this.m_CurrentHandle).sub(this.m_PrevHandle).divideScalar(e), this.m_HandleVelocities.length === 5 && this.m_HandleVelocities.shift(), this.m_HandleVelocities.push(this.m_HandleVelocity.clone()), this.m_PrevHandle.copy(this.m_CurrentHandle);
+    }
+    this.updateBaseVertices();
+  }
+  /**
+   * Called each frame while the page is falling back into place.
+   * `dt` replaces Time.deltaTime.
+   */
+  updateFalling(t = 1 / 60) {
+    var s, i;
+    let e = !1;
+    if (this.m_IsAutoTurning) {
+      let r = ft(this.m_FallTime / this.m_FallDuration);
+      r = Ft(0, 1, r), r = Ft(0, 1, r), this.m_CurrentHandle.lerpVectors(
+        this.m_StartHandle,
+        this.m_EndHandle,
+        this.m_IsFallingLeft ? r : 1 - r
+      ), this.m_FallTime += t, e = Math.abs(r - 1) < pe;
+    } else {
+      const r = new c.Vector3(
+        this.m_FallTime,
+        0,
+        this.m_FallTime * 0.75
+      );
+      this.m_CurrentHandle = le(
+        this.m_CurrentHandle,
+        this.m_EndHandle,
+        this.m_HandleVelocity,
+        r,
+        1 / 0,
+        t
+      ), e = Math.abs(this.m_EndHandle.x - this.m_CurrentHandle.x) < 1e-4;
+    }
+    if (e) {
+      if (this.m_IsFallingLeft) {
+        const r = this.m_Transform.scale;
+        r.x *= -1, this.m_IsRolling = !1, this.m_IsFallingLeft = !1, this.m_IsFalling = !1, this.switchMeshData(
+          1
+          /* Lowpoly */
+        ), this.m_ZTime = this.m_Transform.scale.x === -1 ? 1 : 0, this.m_Book.bound.updatePaperPosition(this), this.updateMaterials();
+      } else
+        this.m_ZTime = this.m_Transform.scale.x === -1 ? 1 : 0, this.m_IsRolling = !1, this.m_IsFallingLeft = !1, this.m_IsFalling = !1, this.switchMeshData(
+          1
+          /* Lowpoly */
+        ), this.updateMaterials();
+      this.isOnRightStack ? (s = this.m_Next) == null || s.trySwitchMeshData(2) : (i = this.m_Prev) == null || i.trySwitchMeshData(2), this.m_IsAutoTurning && this.updateTurningRadius(), this.m_IsAutoTurning = !1;
+      return;
+    }
+    this.updateBaseVertices();
+  }
+  getTextureCoordinate(t) {
+    const e = this.raycastLocal(t, !0);
+    return e !== null ? this.hit2UV(e) : new c.Vector2(0, 0);
+  }
+  raycast(t) {
+    const e = {
+      point: new c.Vector3(),
+      textureCoordinate: new c.Vector2(),
+      pageContent: null,
+      paperIndex: 0,
+      pageIndex: 0
+    };
+    if (!this.isFalling && !this.isTurning) {
+      const s = this.raycastLocal(t);
+      if (s !== null)
+        return e.pageContent = this.isOnRightStack ? this.m_FrontContent : this.m_BackContent, e.point = this.m_Transform.localToWorld(s.clone()), e.textureCoordinate = this.hit2UV(s), e.paperIndex = this.index, { hit: !0, hitInfo: e };
+    }
+    return { hit: !1, hitInfo: e };
+  }
+  hit2UV(t) {
+    const e = new c.Vector2(
+      gt(-this.sizeXOffset, this.m_Size.x, t.x),
+      t.z / this.m_Size.y
+    );
+    this.m_UVMargin.fixUV(e);
+    const s = this.m_Book.direction;
+    if (s === X.UpToDown || s === X.DownToUp) {
+      const i = e.x;
+      e.x = e.y, e.y = i, this.isOnRightStack && (e.y = 1 - e.y);
+    } else
+      this.isOnRightStack || (e.x = 1 - e.x);
+    return e;
+  }
+  /**
+   * Internal raycast against the paper plane in local space.
+   * Returns the local-space hit point, or null if no hit / out of bounds.
+   */
+  raycastLocal(t, e = !1) {
+    t = It(
+      t,
+      this.m_Transform.matrixWorld.clone().invert()
+    );
+    const s = new c.Plane(new c.Vector3(0, 1, 0), 0), i = new c.Vector3();
+    if (t.intersectPlane(s, i) !== null) {
+      const r = i;
+      if (r.x > 0 && r.x < this.m_Size.x && r.z > 0 && r.z < this.m_Size.y || e)
+        return r;
+    }
+    return null;
+  }
+  trySwitchMeshData(t) {
+    this.m_IsFalling || this.m_IsTurning || (this.switchMeshData(t), this.updateMaterials());
+  }
+  switchMeshData(t) {
+    if (t === 2 && (this.m_LowpolyHoleMeshData == null || this.m_NoHole) && (t = 1), this.m_MeshDataType === t) return;
+    this.m_MeshDataType === 0 && this.m_HighpolyMeshDataPool.free(this.m_MeshData);
+    let e = this.m_Book.castShadows;
+    switch (this.m_Book.reduceShadows && t !== 0 && (e = !1), this.m_Renderer.castShadows = e, this.m_MeshDataType = t, t) {
+      case 0:
+        this.m_MeshData = this.m_HighpolyMeshDataPool.get();
+        break;
+      case 1:
+        this.m_MeshData = this.m_LowpolyMeshData;
+        break;
+      case 2:
+        this.m_MeshData = this.m_LowpolyHoleMeshData;
+        break;
+    }
+    this.m_Renderer.mesh = this.m_MeshData.geometry, this.m_isMeshChanged = !0;
+  }
+  updateMaterials() {
+    const t = this.m_MeshData.pattern.subMeshCount;
+    this.m_SubMeshCount !== t && (this.m_Renderer.setMaterials(
+      t === 1 ? this.m_MaterialData.materials1 : this.m_MaterialData.materials3
+    ), this.m_SubMeshCount = t);
+    const e = this.m_FrontContent.textureST.clone();
+    let s = this.m_BackContent.textureST.clone();
+    this.m_Book.direction > 1 ? s = ge(s) : s = _e(s);
+    const i = this.m_FrontContent.texture, r = this.m_BackContent.texture;
+    if (t === 3) {
+      let o = 0, a = 1;
+      this.m_Transform.scale.x === -1 && (o = 1, a = 0), this.m_MaterialData.updatePropertyBlock(i, e), this.m_Renderer.setPropertyBlock(
+        this.m_MaterialData.propertyBlock,
+        o
+      ), this.m_UseBackContentForSides || this.m_Renderer.setPropertyBlock(
+        this.m_MaterialData.propertyBlock,
+        2
+      ), this.m_MaterialData.updatePropertyBlock(r, s), this.m_Renderer.setPropertyBlock(
+        this.m_MaterialData.propertyBlock,
+        a
+      ), this.m_UseBackContentForSides && this.m_Renderer.setPropertyBlock(
+        this.m_MaterialData.propertyBlock,
+        2
+      );
+    } else
+      this.m_Transform.scale.x === -1 ? this.m_MaterialData.updatePropertyBlock(r, s) : this.m_MaterialData.updatePropertyBlock(i, e), this.m_Renderer.setPropertyBlock(
+        this.m_MaterialData.propertyBlock,
+        0
+      );
+  }
+  updateBaseVertices() {
+    if (this.clampHandle(), this.updateCylinder(), this.updateTime(), !this.m_IsRolling) return;
+    this.m_MeshData.updateBaseVertices();
+    const t = this.m_MeshData.baseVertices, e = this.m_Cylinder, s = t.length;
+    for (let i = 0; i < s; i++)
+      t[i] = e.rollPoint(t[i]);
+  }
+  updateMesh() {
+    this.updateMaterials(), this.m_MeshData.updateMesh(), this.m_isMeshChanged = !0;
+  }
+  getDirection(t) {
+    let e = new c.Vector3(0, 0, t), s = new c.Vector3(0.1, 0, t);
+    return e = this.rollPoint(e), s = this.rollPoint(s), e = this.m_Transform.localToWorld(e), s = this.m_Transform.localToWorld(s), this.m_Transform.parent && (e = this.m_Transform.parent.worldToLocal(e), s = this.m_Transform.parent.worldToLocal(s)), e.sub(s).normalize();
+  }
+  updateTime() {
+    if (this.isTurning || this.isFalling) {
+      const t = this.findTime(new c.Vector3(this.m_Size.x, 0, 0)), e = this.findTime(
+        new c.Vector3(this.m_Size.x, 0, this.m_Size.y)
+      );
+      this.m_XTime = Dt(
+        Math.min(t, e),
+        Math.max(t, e),
+        0.9
+      );
+      const s = this.m_MeshData.pattern.baseXArray, i = this.m_MeshData.pattern.baseZArray, r = this.rollPoint(new c.Vector3(s[1], 0, 0)), o = this.rollPoint(new c.Vector3(s[2], 0, 0)), a = this.rollPoint(
+        new c.Vector3(s[1], 0, i[i.length - 1])
+      ), h = this.rollPoint(
+        new c.Vector3(s[2], 0, i[i.length - 1])
+      ), u = o.clone().sub(r).normalize(), l = h.clone().sub(a).normalize(), d = Vt * Math.atan2(u.y, u.x), p = Vt * Math.atan2(l.y, l.x), g = (d + p) / 2;
+      this.m_ZTime = g / 180;
+    } else
+      this.m_XTime = 0, this.m_ZTime = 0;
+  }
+  findTime(t) {
+    return t = this.rollPoint(t), gt(this.m_Size.x, -this.m_Size.x, t.x);
+  }
+  clampHandle() {
+    this.m_StartHandle.y = 0, this.m_CurrentHandle.y = 0;
+    const t = this.m_CurrentHandle.clone(), e = new c.Vector3(0, 0, 0), s = new c.Vector3(0, 0, this.m_Size.y), i = e.distanceTo(this.m_StartHandle), r = s.distanceTo(this.m_StartHandle), o = Math.max(i - this.m_TurningRadius, 0.01), a = Math.max(r - this.m_TurningRadius, 0.01), h = this.m_StartHandle.z, u = new c.Vector2(
+      0,
+      h + (e.z - h) * (o / i)
+    ), l = new c.Vector2(
+      0,
+      h + (s.z - h) * (a / r)
+    ), d = new c.Vector2(i, o), p = new c.Vector2(r, a);
+    t.x = zt(t.x, -this.m_Size.x, this.m_Size.x);
+    const g = ue(t), m = bt(
+      new c.Vector2(g.x, g.y),
+      u,
+      d
+    ), _ = bt(
+      new c.Vector2(m.x, m.y),
+      l,
+      p
+    ), f = ce(
+      new c.Vector3(_.x, _.y, 0)
+    );
+    this.m_CurrentHandle.copy(f);
+  }
+  updateCylinder() {
+    const t = this.m_StartHandle.clone(), e = this.m_CurrentHandle.clone(), s = t.clone().sub(e).normalize();
+    s.length() === 0 && s.set(1, 0, 0);
+    const i = t.clone().sub(
+      s.clone().multiplyScalar(
+        this.m_Size.x * 2 + this.m_TurningRadius * Math.PI
+      )
+    ), r = t.clone(), o = new pt();
+    o.radius = this.m_TurningRadius, o.direction = new c.Vector3(
+      -s.z,
+      0,
+      s.x
+    );
+    for (let a = 0; a < 100; a++) {
+      o.position = i.clone().add(r).multiplyScalar(0.5), this.m_Cylinder = o, this.m_Book.bound.updatePaperPosition(this);
+      const h = o.rollPoint(t.clone());
+      if (Math.abs(e.x - h.x) < 1e-4) break;
+      h.x > e.x ? r.copy(o.position) : i.copy(o.position);
+    }
+  }
+  rollPoint(t) {
+    return this.m_IsRolling ? this.m_Cylinder.rollPoint(t) : t;
+  }
+  drawWireframe(t) {
+  }
+  startAutoTurning(t, e, s, i) {
+    var u, l;
+    if (this.updateTurningRadius(s), this.m_PrevHandle.copy(this.m_CurrentHandle), this.m_IsRolling = !0, this.m_HandleOffset.set(0, 0, 0), t === 0) {
+      const d = this.m_Transform.scale;
+      d.x *= -1;
+    }
+    this.switchMeshData(
+      0
+      /* Highpoly */
+    ), (u = this.m_Prev) == null || u.trySwitchMeshData(1), (l = this.m_Next) == null || l.trySwitchMeshData(1), this.m_IsFallingLeft = t === 1, this.m_IsTurning = !1, this.m_IsFalling = !0, this.m_FallTime = 0, this.m_FallDuration = i;
+    const r = this.m_Size.x, o = this.m_Size.y;
+    e = zt(e, -0.99, 0.99);
+    const a = At(0.5, 1, e), h = At(0.5, 0, e);
+    this.m_StartHandle.set(r, 0, o * a), this.m_EndHandle.set(-r, 0, o * h), this.m_IsAutoTurning = !0;
+  }
+  // ---- Public getter for the cylinder (used by BookBound etc.) ----
+  get cylinder() {
+    return this.m_Cylinder;
+  }
+}
+const Y = class Y {
+  constructor() {
+    this.m_Left = 0, this.m_Right = 0, this.m_Down = 0, this.m_Up = 0;
+  }
+  // ── Properties ────────────────────────────────────────────────────────
+  get left() {
+    return this.m_Left;
+  }
+  set left(t) {
+    this.m_Left = this.clamp(t);
+  }
+  get right() {
+    return this.m_Right;
+  }
+  set right(t) {
+    this.m_Right = this.clamp(t);
+  }
+  get down() {
+    return this.m_Down;
+  }
+  set down(t) {
+    this.m_Down = this.clamp(t);
+  }
+  get up() {
+    return this.m_Up;
+  }
+  set up(t) {
+    this.m_Up = this.clamp(t);
+  }
+  // ── Helpers ───────────────────────────────────────────────────────────
+  clamp(t) {
+    return Math.max(Y.kMin, Math.min(t, Y.kMax));
+  }
+  // ── Transform ─────────────────────────────────────────────────────────
+  /**
+   * Returns a new PaperUVMargin with margins remapped according to the
+   * book direction.
+   */
+  transform(t) {
+    const e = new Y();
+    switch (t) {
+      case X.LeftToRight:
+        e.m_Left = this.m_Left, e.m_Right = this.m_Right, e.m_Down = this.m_Down, e.m_Up = this.m_Up;
+        break;
+      case X.RightToLeft:
+        e.m_Left = this.m_Right, e.m_Right = this.m_Left, e.m_Down = this.m_Down, e.m_Up = this.m_Up;
+        break;
+      case X.UpToDown:
+        e.m_Left = this.m_Up, e.m_Right = this.m_Down, e.m_Down = this.m_Left, e.m_Up = this.m_Right;
+        break;
+      case X.DownToUp:
+      default:
+        e.m_Left = this.m_Down, e.m_Right = this.m_Up, e.m_Down = this.m_Left, e.m_Up = this.m_Right;
+        break;
+    }
+    return e;
+  }
+  // ── FixUV ─────────────────────────────────────────────────────────────
+  /**
+   * Remap a UV coordinate so that (0,0) and (1,1) correspond to the
+   * content area inside the margins.
+   *
+   * Unity's `Mathf.InverseLerp(a, b, v)` = `(v - a) / (b - a)` clamped to [0,1].
+   */
+  fixUV(t) {
+    return t.x = Y.inverseLerp(this.m_Left, 1 - this.m_Right, t.x), t.y = Y.inverseLerp(this.m_Down, 1 - this.m_Up, t.y), t;
+  }
+  static inverseLerp(t, e, s) {
+    if (t === e) return 0;
+    const i = (s - t) / (e - t);
+    return Math.max(0, Math.min(1, i));
+  }
+  // ── Value-type clone ──────────────────────────────────────────────────
+  clone() {
+    const t = new Y();
+    return t.m_Left = this.m_Left, t.m_Right = this.m_Right, t.m_Down = this.m_Down, t.m_Up = this.m_Up, t;
+  }
+};
+Y.kMin = 0, Y.kMax = 0.25;
+let yt = Y;
+const U = class U {
+  constructor(t) {
+    this.m_Material = null, this.m_Color = new c.Color(1, 1, 1), this.m_Width = 0, this.m_Height = 0, this.m_Thickness = 0, this.m_Stiffness = 0, this.m_Quality = 0, this.m_UVMargin = new yt(), this.margin = 0, this.bookDirection = X.LeftToRight, this.color = (t == null ? void 0 : t.color) ?? new c.Color(1, 1, 1), this.width = (t == null ? void 0 : t.width) ?? U.kMinSize * 2, this.height = (t == null ? void 0 : t.height) ?? U.kMinSize * 2, this.thickness = (t == null ? void 0 : t.thickness) ?? U.kMinThickness * 2, this.stiffness = (t == null ? void 0 : t.stiffness) ?? 0.1, this.quality = (t == null ? void 0 : t.quality) ?? 3, (t == null ? void 0 : t.material) !== void 0 && (this.m_Material = t.material);
+  }
+  // ── Properties ────────────────────────────────────────────────────────
+  get material() {
+    return this.m_Material;
+  }
+  set material(t) {
+    this.m_Material = t;
+  }
+  get color() {
+    return this.m_Color;
+  }
+  set color(t) {
+    this.m_Color = t;
+  }
+  get width() {
+    return this.bookDirection > 1 ? this.m_Height : this.m_Width;
+  }
+  set width(t) {
+    this.m_Width = Math.max(t, U.kMinSize);
+  }
+  get height() {
+    return this.bookDirection > 1 ? this.m_Width : this.m_Height;
+  }
+  set height(t) {
+    this.m_Height = Math.max(t, U.kMinSize);
+  }
+  get thickness() {
+    return this.m_Thickness;
+  }
+  set thickness(t) {
+    this.m_Thickness = Math.max(t, U.kMinThickness);
+  }
+  get stiffness() {
+    return this.m_Stiffness;
+  }
+  set stiffness(t) {
+    this.m_Stiffness = Math.max(0, Math.min(1, t));
+  }
+  get quality() {
+    return this.m_Quality;
+  }
+  set quality(t) {
+    this.m_Quality = Math.max(
+      U.kMinQuality,
+      Math.min(t, U.kMaxQuality)
+    );
+  }
+  get uvMargin() {
+    return this.m_UVMargin.transform(this.bookDirection);
+  }
+  set uvMargin(t) {
+    this.m_UVMargin = t;
+  }
+  get size() {
+    return new c.Vector2(this.width, this.height);
+  }
+};
+U.kMinSize = 1, U.kMinThickness = 1e-4, U.kMinQuality = 1, U.kMaxQuality = 5;
+let lt = U;
+class Ht {
+  constructor(t) {
+    this.m_Texture = null, this.m_TextureST = new c.Vector4(1, 1, 0, 0);
+    const e = t.material ?? new c.MeshStandardMaterial();
+    this.m_Materials1 = [e.clone()], this.m_Materials3 = [e.clone(), e.clone(), e.clone()], this.m_Color = t.color.clone();
+  }
+  get materials1() {
+    return this.m_Materials1;
+  }
+  get materials3() {
+    return this.m_Materials3;
+  }
+  get color() {
+    return this.m_Color;
+  }
+  get texture() {
+    return this.m_Texture;
+  }
+  get textureST() {
+    return this.m_TextureST;
+  }
+  /**
+   * Mirrors Unity's MaterialPropertyBlock: stores color, texture, and textureST.
+   * Paper.ts reads this after calling updatePropertyBlock.
+   */
+  get propertyBlock() {
+    return {
+      color: this.m_Color.clone(),
+      map: this.m_Texture,
+      textureST: this.m_TextureST.clone()
+    };
+  }
+  updatePropertyBlock(t, e) {
+    this.m_Texture = t, this.m_TextureST.copy(e);
+  }
+}
+function Ot(n, t, e, s = new c.Vector3()) {
+  let i = t.x - n.x, r = t.y - n.y, o = t.z - n.z, a = 1 / Math.sqrt(i * i + r * r + o * o);
+  i *= a, r *= a, o *= a;
+  let h = e.x - n.x, u = e.y - n.y, l = e.z - n.z;
+  a = 1 / Math.sqrt(h * h + u * u + l * l), h *= a, u *= a, l *= a;
+  const d = r * l - o * u, p = o * h - i * l, g = i * u - r * h;
+  return a = 1 / Math.sqrt(d * d + p * p + g * g), s.set(d * a, p * a, g * a);
+}
+class it {
+  constructor(t, e = !1, s = !1) {
+    this.prev = null, this.next = null, this.index = 0, this.value = t, this.hole = e, this.seam = s;
+  }
+  // ── Navigation properties ─────────────────────────────────────────────
+  get prevNoneSeam() {
+    return this.prev.seam ? this.prev.prevNoneSeam : this.prev;
+  }
+  get nextNoneSeam() {
+    return this.next.seam ? this.next.nextNoneSeam : this.next;
+  }
+  get prevNoneHole() {
+    return this.prev.hole ? this.prev.prevNoneHole : this.prev;
+  }
+  get nextNoneHole() {
+    return this.next.hole ? this.next.nextNoneHole : this.next;
+  }
+  // ── Factory helpers ───────────────────────────────────────────────────
+  createNext(t, e = !1, s = !1) {
+    const i = new it(t, e, s);
+    return i.prev = this, this.next = i, i;
+  }
+  // C# had a double overload — in TS numbers are already IEEE 754 doubles.
+  // Keeping a separate method for parity; it simply casts to number.
+  createNextFromDouble(t, e = !1, s = !1) {
+    const i = new it(t, e, s);
+    return i.prev = this, this.next = i, i;
+  }
+  // ── Insertion (sorted linked-list insert) ─────────────────────────────
+  insert(t) {
+    return this.value >= t.value || this.next === null ? !1 : this.next.value > t.value ? Math.abs(this.value - t.value) < 1e-4 || Math.abs(this.next.value - t.value) < 1e-4 ? !1 : (this.next.prev = t, t.next = this.next, t.prev = this, this.next = t, t.hole = this.hole, !0) : this.next.insert(t);
+  }
+  // ── Index assignment (recursive) ──────────────────────────────────────
+  updateIndex(t) {
+    this.index = t, this.next !== null && this.next.updateIndex(t + 1);
+  }
+  getValues(t) {
+    if (t === void 0) {
+      const e = [];
+      return this._getValuesRecursive(e), e;
+    }
+    this._getValuesRecursive(t);
+  }
+  _getValuesRecursive(t) {
+    t.push(this.value), this.next !== null && this.next._getValuesRecursive(t);
+  }
+  getHoles(t) {
+    if (t === void 0) {
+      const e = [];
+      return this._getHolesRecursive(e), e;
+    }
+    this._getHolesRecursive(t);
+  }
+  _getHolesRecursive(t) {
+    t.push(this.hole), this.next !== null && this.next._getHolesRecursive(t);
+  }
+}
+class wt {
+  constructor(t, e, s, i) {
+    this.active = !0, this.prevIndex = t, this.index = e, this.nextIndex = s, this.time = i;
+  }
+  clone() {
+    const t = new wt(this.prevIndex, this.index, this.nextIndex, this.time);
+    return t.active = this.active, t;
+  }
+}
+class St {
+  constructor(t, e, s, i, r, o = !0) {
+    this.startX = t, this.startZ = e, this.endX = s, this.endZ = i, this.flip = r, this.left = o;
+  }
+  clone() {
+    return new St(
+      this.startX,
+      this.startZ,
+      this.endX,
+      this.endZ,
+      this.flip,
+      this.left
+    );
+  }
+}
+class Me {
+  constructor(t, e, s) {
+    const i = t.size;
+    this.leftNode = new it(e.left * i.x, s, !0), this.rightNode = new it((1 - e.right) * i.x, s, !0), this.downNode = new it(e.down * i.y, s, !0), this.upNode = new it((1 - e.up) * i.y, s, !0);
+  }
+  insert(t, e, s, i) {
+    t.insert(this.leftNode) && s.push(this.leftNode), t.insert(this.rightNode) && s.push(this.rightNode), e.insert(this.downNode) && i.push(this.downNode), e.insert(this.upNode) && i.push(this.upNode);
+  }
+}
+function mt(n, t, e) {
+  if (n === t) return 0;
+  const s = (e - n) / (t - n);
+  return Math.max(0, Math.min(1, s));
+}
+function Zt(n, t) {
+  for (const e of n) {
+    const s = e.prevNoneSeam, i = e.nextNoneSeam, r = mt(s.value, i.value, e.value), o = new wt(s.index, e.index, i.index, r);
+    t.push(o);
+  }
+}
+function Nt(n, t, e, s, i) {
+  for (const r of n) {
+    if (!r.active) return;
+    for (let o = 0; o < s; o++) {
+      const a = r.prevIndex, h = r.nextIndex, u = t[o * e + a], l = t[o * e + h], d = t[o * e + r.index];
+      i ? Jt(u, l, r.time, d) : d.copy(u).lerp(l, r.time);
+    }
+  }
+}
+function Lt(n, t, e, s, i) {
+  for (const r of n) {
+    if (!r.active) return;
+    for (let o = 0; o < e; o++) {
+      const a = r.prevIndex, h = r.nextIndex, u = t[a * e + o], l = t[h * e + o], d = t[r.index * e + o];
+      i ? Jt(u, l, r.time, d) : d.copy(u).lerp(l, r.time);
+    }
+  }
+}
+function Jt(n, t, e, s = new c.Vector3()) {
+  const i = Math.sqrt(n.x * n.x + n.y * n.y + n.z * n.z), r = Math.sqrt(t.x * t.x + t.y * t.y + t.z * t.z);
+  if (i === 0 || r === 0)
+    return s.copy(n).lerp(t, e);
+  const o = n.x / i, a = n.y / i, h = n.z / i, u = t.x / r, l = t.y / r, d = t.z / r;
+  let p = o * u + a * l + h * d;
+  p = Math.max(-1, Math.min(1, p));
+  const g = Math.acos(p);
+  if (g < 1e-6)
+    return s.copy(n).lerp(t, e);
+  const m = Math.sin(g), _ = Math.sin((1 - e) * g) / m, f = Math.sin(e * g) / m, T = i + (r - i) * e;
+  return s.set(
+    (o * _ + u * f) * T,
+    (a * _ + l * f) * T,
+    (h * _ + d * f) * T
+  );
+}
+function xe(n, t, e, s, i) {
+  for (const r of n) {
+    const o = (r.endX - r.startX + 1) * 2, a = (r.endZ - r.startZ + 1) * 2, h = e.length;
+    for (let l = 0, d = r.endX - r.startX; l < d; l++) {
+      const p = h + l * 2 + 0, g = h + l * 2 + 1, m = h + l * 2 + 2, _ = h + l * 2 + 3;
+      r.flip ? Et(t, p, g, m, _, o) : Ut(t, p, g, m, _, o);
+    }
+    if (r.left)
+      for (let l = 0, d = r.endZ - r.startZ; l < d; l++) {
+        const p = h + l * 2 + 0 + o * 2, g = h + l * 2 + 1 + o * 2, m = h + l * 2 + 2 + o * 2, _ = h + l * 2 + 3 + o * 2;
+        r.flip ? Et(t, p, g, m, _, a) : Ut(t, p, g, m, _, a);
+      }
+    else
+      for (let l = 0, d = r.endZ - r.startZ; l < d; l++) {
+        const p = h + l * 2 + 0 + o * 2 + a, g = h + l * 2 + 1 + o * 2 + a, m = h + l * 2 + 2 + o * 2 + a, _ = h + l * 2 + 3 + o * 2 + a;
+        r.flip ? xt(t, p, g, m, _) : Mt(t, p, g, m, _);
+      }
+    const u = s * i;
+    for (let l = r.startX; l <= r.endX; l++) {
+      const d = r.startZ * s + l;
+      e.push(e[d].clone()), e.push(e[d + u].clone());
+    }
+    for (let l = r.startX; l <= r.endX; l++) {
+      const d = l + r.endZ * s;
+      e.push(e[d + u].clone()), e.push(e[d].clone());
+    }
+    for (let l = r.startZ; l <= r.endZ; l++) {
+      const d = r.startX + l * s;
+      e.push(e[d + u].clone()), e.push(e[d].clone());
+    }
+    for (let l = r.startZ; l <= r.endZ; l++) {
+      const d = l * s + r.endX;
+      e.push(e[d].clone()), e.push(e[d + u].clone());
+    }
+  }
+}
+function Ce(n, t, e, s, i) {
+  const r = s * i;
+  let o = r * 2;
+  const a = new c.Vector3();
+  for (const h of n) {
+    for (let u = h.startX; u <= h.endX; u++) {
+      const l = u + h.startZ * s, d = t[l], p = t[l + s];
+      a.subVectors(d, p).normalize(), h.flip && a.multiplyScalar(-1), e[o].copy(a), t[o++].copy(d), e[o].copy(a), t[o++].copy(t[l + r]);
+    }
+    for (let u = h.startX; u <= h.endX; u++) {
+      const l = u + h.endZ * s, d = t[l + r], p = t[l + r - s];
+      a.subVectors(d, p).normalize(), h.flip && a.multiplyScalar(-1), e[o].copy(a), t[o++].copy(d), e[o].copy(a), t[o++].copy(t[l]);
+    }
+    for (let u = h.startZ; u <= h.endZ; u++) {
+      const l = u * s + h.startX, d = t[l + r], p = t[l + r + 1];
+      a.subVectors(d, p).normalize(), h.flip && a.multiplyScalar(-1), e[o].copy(a), t[o++].copy(d), e[o].copy(a), t[o++].copy(t[l]);
+    }
+    for (let u = h.startZ; u <= h.endZ; u++) {
+      const l = u * s + h.endX, d = t[l], p = t[l - 1];
+      a.subVectors(d, p).normalize(), h.flip && a.multiplyScalar(-1), e[o].copy(a), t[o++].copy(d), e[o].copy(a), t[o++].copy(t[l + r]);
+    }
+  }
+}
+function Ut(n, t, e, s, i, r) {
+  Mt(n, t, e, s, i), t += r, e += r, s += r, i += r, Mt(n, t, e, s, i);
+}
+function Et(n, t, e, s, i, r) {
+  xt(n, t, e, s, i), t += r, e += r, s += r, i += r, xt(n, t, e, s, i);
+}
+function Pe(n, t, e, s, i, r, o) {
+  Mt(n, e, s, i, r), e += o, s += o, i += o, r += o, xt(t, e, s, i, r);
+}
+function ye(n, t, e, s, i, r) {
+  const o = i.left * s.x, a = (1 - i.right) * s.x, h = i.down * s.y, u = (1 - i.up) * s.y, l = t.length, d = e.length;
+  if (r > 1)
+    for (let g = 0; g < d; g++)
+      for (let m = 0; m < l; m++) {
+        const _ = mt(a, o, t[m]), f = mt(u, h, e[g]);
+        n.push(new c.Vector2(f, _));
+      }
+  else
+    for (let g = 0; g < d; g++)
+      for (let m = 0; m < l; m++) {
+        const _ = mt(o, a, t[m]), f = mt(u, h, e[g]);
+        n.push(new c.Vector2(_, f));
+      }
+  const p = n.length;
+  for (let g = 0; g < p; g++)
+    n.push(n[g].clone());
+}
+function Mt(n, t, e, s, i) {
+  n.push(t), n.push(s), n.push(e), n.push(e), n.push(s), n.push(i);
+}
+function xt(n, t, e, s, i) {
+  n.push(t), n.push(e), n.push(s), n.push(e), n.push(i), n.push(s);
+}
+function Te(n, t, e, s) {
+  const i = [];
+  for (let r = 0; r < e - 1; r++)
+    for (let o = 0; o < t - 1; o++) {
+      let a = n[r * t + o].clone(), h = n[r * t + o + 1].clone(), u = n[(r + 1) * t + o].clone(), l = n[(r + 1) * t + o + 1].clone();
+      a.applyMatrix4(s), h.applyMatrix4(s), u.applyMatrix4(s), l.applyMatrix4(s), i.push([a, h, u, l]);
+    }
+  return i;
+}
+class Xt {
+  get geometry() {
+    return this.m_Geometry;
+  }
+  get pattern() {
+    return this.m_Pattern;
+  }
+  get baseVertices() {
+    return this.m_BaseVertices;
+  }
+  constructor(t, e) {
+    this.m_Pattern = e, this.m_BaseVertices = new Array(e.baseVertexCount);
+    for (let o = 0; o < e.baseVertexCount; o++)
+      this.m_BaseVertices[o] = new c.Vector3();
+    this.m_Vertices = new Array(e.vertexCount);
+    for (let o = 0; o < e.vertexCount; o++)
+      this.m_Vertices[o] = new c.Vector3();
+    this.m_Normals = new Array(e.vertexCount);
+    for (let o = 0; o < e.vertexCount; o++)
+      this.m_Normals[o] = new c.Vector3();
+    if (this.m_Geometry = t, this.m_Pattern.subMeshCount === 1) {
+      const o = new Uint32Array(e.triangles);
+      this.m_Geometry.setIndex(new c.BufferAttribute(o, 1)), this.m_Geometry.addGroup(0, e.triangles.length, 0);
+    } else {
+      const o = e.frontTriangles.length + e.backTriangles.length + e.borderTriangles.length, a = new Uint32Array(o);
+      let h = 0;
+      a.set(e.frontTriangles, h), this.m_Geometry.addGroup(h, e.frontTriangles.length, 0), h += e.frontTriangles.length, a.set(e.backTriangles, h), this.m_Geometry.addGroup(h, e.backTriangles.length, 1), h += e.backTriangles.length, a.set(e.borderTriangles, h), this.m_Geometry.addGroup(h, e.borderTriangles.length, 2), this.m_Geometry.setIndex(new c.BufferAttribute(a, 1));
+    }
+    const s = new Float32Array(e.vertexCount * 3), i = new Float32Array(e.vertexCount * 3), r = new Float32Array(e.vertexCount * 2);
+    for (let o = 0; o < e.texcoords.length; o++)
+      r[o * 2] = e.texcoords[o].x, r[o * 2 + 1] = e.texcoords[o].y;
+    this.m_Geometry.setAttribute(
+      "position",
+      new c.BufferAttribute(s, 3)
+    ), this.m_Geometry.setAttribute(
+      "normal",
+      new c.BufferAttribute(i, 3)
+    ), this.m_Geometry.setAttribute(
+      "uv",
+      new c.BufferAttribute(r, 2)
+    ), this.updateBaseVertices();
+  }
+  // ── UpdateBaseVertices ──────────────────────────────────────────────────
+  /**
+   * Recalculates base vertex positions from the pattern's X/Z arrays
+   * and offset.
+   *
+   * Ported from lines ~2167-2183.
+   */
+  updateBaseVertices() {
+    const t = this.m_BaseVertices, e = this.m_Pattern.baseXArray, s = this.m_Pattern.baseZArray, i = this.m_Pattern.baseXOffset, r = e.length, o = s.length;
+    let a = 0;
+    for (let h = 0; h < o; h++)
+      for (let u = 0; u < r; u++)
+        t[a++].set(e[u] + i, 0, s[h]);
+  }
+  // ── UpdateMesh ─────────────────────────────────────────────────────────
+  /**
+   * Recomputes all vertex positions and normals.
+   *
+   * Algorithm:
+   * 1. Clear normals for all base vertices.
+   * 2. Interpolate seam positions in X and Z.
+   * 3. Accumulate face normals per quad onto each vertex.
+   * 4. Normalise by dividing by weight and re-normalising.
+   * 5. Interpolate seam normals (with slerp).
+   * 6. Offset front/back by +/- halfThickness along normal.
+   * 7. Update border vertex positions and normals.
+   * 8. Push data into BufferGeometry attributes.
+   *
+   * Ported from lines ~2185-2255.
+   */
+  updateMesh() {
+    const t = this.m_BaseVertices, e = this.m_Vertices, s = this.m_Normals, i = this.m_Pattern.weights, r = this.m_Pattern.baseXArray.length, o = this.m_Pattern.baseZArray.length, a = this.m_Pattern.baseVertexCount, h = new c.Vector3(), u = new c.Vector3(), l = new c.Vector3();
+    for (let m = 0; m < a; m++)
+      s[m].set(0, 0, 0);
+    Nt(this.m_Pattern.xSeams, t, r, o, !1), Lt(this.m_Pattern.zSeams, t, r, o, !1);
+    for (let m = 0; m < o - 1; m++) {
+      const _ = m + 1;
+      for (let f = 0; f < r - 1; f++) {
+        const T = f + 1, b = m * r + f, x = m * r + T, P = _ * r + f, S = _ * r + T, k = t[b], O = t[x], Z = t[P], z = t[S];
+        Ot(k, Z, O, h), Ot(z, O, Z, u), l.addVectors(h, u), s[b].add(l), s[x].add(l), s[P].add(l), s[S].add(l);
+      }
+    }
+    for (let m = 0; m < a; m++)
+      s[m].divideScalar(i[m]).normalize();
+    Nt(this.m_Pattern.xSeams, s, r, o, !0), Lt(this.m_Pattern.zSeams, s, r, o, !0);
+    const d = this.m_Pattern.thickness / 2;
+    for (let m = 0; m < a; m++) {
+      const _ = s[m];
+      s[m + a].copy(_).negate();
+      const f = t[m];
+      e[m].copy(f).addScaledVector(_, d), e[m + a].copy(f).addScaledVector(_, -d);
+    }
+    Ce(this.m_Pattern.borders, e, s, r, o);
+    const p = this.m_Geometry.getAttribute(
+      "position"
+    ), g = this.m_Geometry.getAttribute(
+      "normal"
+    );
+    for (let m = 0; m < e.length; m++) {
+      const _ = e[m];
+      p.setXYZ(m, _.x, _.y, _.z);
+      const f = s[m];
+      g.setXYZ(m, f.x, f.y, f.z);
+    }
+    p.needsUpdate = !0, g.needsUpdate = !0, this.m_Geometry.computeBoundingBox(), this.m_Geometry.computeBoundingSphere();
+  }
+  // ── DrawWireframe (debug) ──────────────────────────────────────────────
+  /**
+   * Returns wireframe quad data for debug visualisation.
+   *
+   * Ported from lines ~2257-2262.
+   */
+  drawWireframe(t) {
+    const e = this.m_Pattern.baseXArray.length, s = this.m_Pattern.baseZArray.length;
+    return Te(this.m_Vertices, e, s, t);
+  }
+}
+class we {
+  constructor() {
+    this.m_UsedMeshs = [], this.m_FreeMeshs = [], this.m_Meshs = /* @__PURE__ */ new Set();
+  }
+  get() {
+    let t;
+    return this.m_FreeMeshs.length > 0 ? t = this.m_FreeMeshs.pop() : (t = new c.BufferGeometry(), this.m_Meshs.add(t)), this.m_UsedMeshs.push(t), t;
+  }
+  recycle() {
+    for (const t of this.m_UsedMeshs)
+      t.deleteAttribute("position"), t.deleteAttribute("normal"), t.deleteAttribute("uv"), t.setIndex(null), t.clearGroups(), this.m_FreeMeshs.push(t);
+    this.m_UsedMeshs.length = 0;
+  }
+  destroy() {
+    for (const t of this.m_Meshs)
+      t.dispose();
+    this.m_Meshs.clear();
+  }
+}
+class Se {
+  constructor(t) {
+    this.m_CreateMeshCollider = !1, this.m_UsedRenderers = [], this.m_FreeRenderers = [], this.m_Renderers = /* @__PURE__ */ new Set(), this.m_Ids = [], this.m_Root = t;
+  }
+  set createColliders(t) {
+    this.m_CreateMeshCollider = t;
+  }
+  get ids() {
+    return [...this.m_Ids];
+  }
+  get(t) {
+    let e;
+    return this.m_FreeRenderers.length > 0 ? (e = this.m_FreeRenderers.pop(), e.createCollider = this.m_CreateMeshCollider, e.reset(t)) : (e = new ke(this.m_Root, t, this.m_CreateMeshCollider), this.m_Renderers.add(e)), this.m_UsedRenderers.push(e), this.m_Ids.push(e.id), e;
+  }
+  recycle() {
+    for (const t of this.m_UsedRenderers)
+      t.clear(), this.m_FreeRenderers.push(t);
+    this.m_UsedRenderers.length = 0, this.m_Ids.length = 0;
+  }
+  destroy() {
+    for (const t of this.m_Renderers)
+      t.destroy();
+    this.m_Renderers.clear();
+  }
+  getBounds() {
+    const t = new c.Box3();
+    let e = !0;
+    for (const s of this.m_UsedRenderers)
+      e ? (t.copy(s.bounds), e = !1) : t.union(s.bounds);
+    return t;
+  }
+}
+let ve = 1;
+class ke {
+  constructor(t, e, s) {
+    this.m_Visibility = !0, this.m_PropertyBlocks = /* @__PURE__ */ new Map(), this.m_MaterialTextures = /* @__PURE__ */ new Map(), this.m_Id = ve++, this.m_Object3D = new c.Object3D(), this.m_Object3D.name = e, this.m_Mesh = new c.Mesh(
+      new c.BufferGeometry(),
+      new c.MeshStandardMaterial()
+    ), this.m_Object3D.add(this.m_Mesh), t.add(this.m_Object3D), this.m_CreateCollider = s;
+  }
+  get createCollider() {
+    return this.m_CreateCollider;
+  }
+  set createCollider(t) {
+    this.m_CreateCollider = t;
+  }
+  get bounds() {
+    const t = new c.Box3();
+    return this.m_Mesh.geometry && (this.m_Mesh.geometry.computeBoundingBox(), this.m_Mesh.geometry.boundingBox && (t.copy(this.m_Mesh.geometry.boundingBox), t.applyMatrix4(this.m_Mesh.matrixWorld))), t;
+  }
+  get id() {
+    return this.m_Id;
+  }
+  get transform() {
+    return this.m_Object3D;
+  }
+  get visibility() {
+    return this.m_Visibility;
+  }
+  set castShadows(t) {
+    this.m_Mesh.castShadow = t;
+  }
+  set mesh(t) {
+    t && (this.m_Mesh.geometry = t);
+  }
+  get meshObject() {
+    return this.m_Mesh;
+  }
+  setMaterials(t) {
+    this.disposeManagedTextures(), this.disposeCurrentMaterials(), Array.isArray(t) ? t.length === 0 ? this.m_Mesh.material = new c.MeshStandardMaterial() : t.length === 1 ? this.m_Mesh.material = t[0].clone() : this.m_Mesh.material = t.map((e) => e.clone()) : this.m_Mesh.material = t.clone(), this.m_PropertyBlocks.clear();
+  }
+  setPropertyBlock(t, e) {
+    this.m_PropertyBlocks.set(e, t);
+    const s = this.getMaterial(e);
+    s && (this.isMapCapable(s) && (t.map instanceof c.Texture ? this.applyTextureProperty(
+      s,
+      e,
+      t.map,
+      t.textureST
+    ) : this.clearMaterialTexture(e, s)), this.isColorCapable(s) && t.color instanceof c.Color && s.color.copy(t.color));
+  }
+  reset(t) {
+    this.m_Object3D.name = t, this.setVisibility(!0), this.m_Mesh.geometry = new c.BufferGeometry(), this.setMaterials([]);
+  }
+  clear() {
+    this.m_Object3D.name = "", this.m_Mesh.geometry = new c.BufferGeometry(), this.m_PropertyBlocks.clear(), this.setVisibility(!1), this.m_Object3D.position.set(0, 0, 0), this.m_Object3D.rotation.set(0, 0, 0), this.m_Object3D.scale.set(1, 1, 1);
+  }
+  destroy() {
+    this.disposeManagedTextures(), this.disposeCurrentMaterials(), this.m_Mesh.geometry && this.m_Mesh.geometry.dispose(), this.m_Object3D.parent && this.m_Object3D.parent.remove(this.m_Object3D);
+  }
+  setVisibility(t) {
+    this.m_Visibility !== t && (this.m_Visibility = t, this.m_Object3D.visible = t);
+  }
+  updateCollider() {
+  }
+  getMaterial(t) {
+    return Array.isArray(this.m_Mesh.material) ? this.m_Mesh.material[t] ?? null : this.m_Mesh.material;
+  }
+  isMapCapable(t) {
+    return "map" in t;
+  }
+  isColorCapable(t) {
+    return "color" in t && t.color instanceof c.Color;
+  }
+  getSTKey(t) {
+    return t ? `${t.x.toFixed(6)},${t.y.toFixed(6)},${t.z.toFixed(6)},${t.w.toFixed(6)}` : "1,1,0,0";
+  }
+  applyTextureProperty(t, e, s, i) {
+    const r = this.getSTKey(i), o = this.m_MaterialTextures.get(e);
+    if (o && o.source === s && o.stKey === r) {
+      t.map !== o.texture && (t.map = o.texture, t.needsUpdate = !0);
+      return;
+    }
+    this.clearManagedTexture(e);
+    const a = s.clone();
+    a.needsUpdate = !0, i && (a.repeat.set(i.x, i.y), a.offset.set(i.z, i.w), a.wrapS = c.RepeatWrapping, a.wrapT = c.RepeatWrapping), t.map = a, t.needsUpdate = !0, this.m_MaterialTextures.set(e, {
+      source: s,
+      texture: a,
+      stKey: r
+    });
+  }
+  clearMaterialTexture(t, e) {
+    this.clearManagedTexture(t), e.map !== null && (e.map = null, e.needsUpdate = !0);
+  }
+  clearManagedTexture(t) {
+    const e = this.m_MaterialTextures.get(t);
+    e && (e.texture.dispose(), this.m_MaterialTextures.delete(t));
+  }
+  disposeManagedTextures() {
+    for (const t of this.m_MaterialTextures.values())
+      t.texture.dispose();
+    this.m_MaterialTextures.clear();
+  }
+  disposeCurrentMaterials() {
+    const t = Array.isArray(this.m_Mesh.material) ? this.m_Mesh.material : [this.m_Mesh.material];
+    for (const e of t)
+      e.dispose();
+  }
+}
+class Be {
+  constructor(t, e, s = !1) {
+    this.m_Stack = [], this.m_SharedData = null, this.m_MeshFactory = t, this.m_Pattern = e, (this.m_UseSharedData = s) && (this.m_SharedData = new Xt(this.m_MeshFactory.get(), this.m_Pattern), this.m_SharedData.updateMesh());
+  }
+  get() {
+    return this.m_UseSharedData ? this.m_SharedData : this.m_Stack.length > 0 ? this.m_Stack.pop() : new Xt(this.m_MeshFactory.get(), this.m_Pattern);
+  }
+  free(t) {
+    if (this.m_UseSharedData) throw new Error("Not implemented");
+    this.m_Stack.push(t);
+  }
+}
+var dt = /* @__PURE__ */ ((n) => (n[n.Next = 0] = "Next", n[n.Back = 1] = "Back", n))(dt || {}), be = /* @__PURE__ */ ((n) => (n[n.Surface = 0] = "Surface", n[n.Edge = 1] = "Edge", n))(be || {}), Ie = /* @__PURE__ */ ((n) => (n[n.Constant = 0] = "Constant", n[n.RandomBetweenTwoConstants = 1] = "RandomBetweenTwoConstants", n[n.Curve = 2] = "Curve", n[n.RandomBetweenTwoCurves = 3] = "RandomBetweenTwoCurves", n))(Ie || {}), Re = /* @__PURE__ */ ((n) => (n[n.PaperIndexTime = 0] = "PaperIndexTime", n[n.TurnIndexTime = 1] = "TurnIndexTime", n))(Re || {});
+class Ve {
+  constructor(t) {
+    this.keys = t ? t.map((e) => ({ time: e.time, value: e.value })) : [];
+  }
+  /**
+   * Evaluate the curve at parameter `t`.
+   * Linear interpolation between keyframes (Unity default is cubic,
+   * but the exact tangent data is not available here).
+   */
+  evaluate(t) {
+    const e = this.keys, s = e.length;
+    if (s === 0) return 0;
+    if (s === 1 || t <= e[0].time) return e[0].value;
+    if (t >= e[s - 1].time) return e[s - 1].value;
+    for (let i = 0; i < s - 1; i++)
+      if (t >= e[i].time && t <= e[i + 1].time) {
+        const r = (t - e[i].time) / (e[i + 1].time - e[i].time);
+        return e[i].value + (e[i + 1].value - e[i].value) * r;
+      }
+    return e[s - 1].value;
+  }
+}
+function ot(n, t, e) {
+  return Math.max(t, Math.min(e, n));
+}
+function ze(n, t, e) {
+  return n === t ? 0 : ot((e - n) / (t - n), 0, 1);
+}
+function jt(n, t) {
+  return n + Math.random() * (t - n);
+}
+class at {
+  constructor(t, e) {
+    this.m_Mode = 0, this.m_Constant = 0, this.m_ConstantMin = 0, this.m_ConstantMax = 0, this.m_Curve = null, this.m_CurveMin = null, this.m_CurveMax = null, this.m_CurveTimeMode = 0, t !== void 0 && (e === void 0 ? (this.m_Constant = t, this.m_ConstantMin = t, this.m_ConstantMax = t, this.m_Curve = null, this.m_CurveMin = null, this.m_CurveMax = null, this.m_Mode = 0, this.m_CurveTimeMode = 0) : (this.m_Constant = 0, this.m_ConstantMin = t, this.m_ConstantMax = e, this.m_Curve = null, this.m_CurveMin = null, this.m_CurveMax = null, this.m_Mode = 1, this.m_CurveTimeMode = 0));
+  }
+  // ── Properties ──────────────────────────────────────────────────────────
+  get mode() {
+    return this.m_Mode;
+  }
+  set mode(t) {
+    this.m_Mode = t;
+  }
+  get constant() {
+    return this.m_Constant;
+  }
+  set constant(t) {
+    this.m_Constant = t;
+  }
+  get constantMin() {
+    return this.m_ConstantMin;
+  }
+  set constantMin(t) {
+    this.m_ConstantMin = t;
+  }
+  get constantMax() {
+    return this.m_ConstantMax;
+  }
+  set constantMax(t) {
+    this.m_ConstantMax = t;
+  }
+  get curve() {
+    return this.m_Curve;
+  }
+  set curve(t) {
+    this.m_Curve = t;
+  }
+  get curveMin() {
+    return this.m_CurveMin;
+  }
+  set curveMin(t) {
+    this.m_CurveMin = t;
+  }
+  get curveMax() {
+    return this.m_CurveMax;
+  }
+  set curveMax(t) {
+    this.m_CurveMax = t;
+  }
+  get curveTimeMode() {
+    return this.m_CurveTimeMode;
+  }
+  set curveTimeMode(t) {
+    this.m_CurveTimeMode = t;
+  }
+  /** A value based on a curve. */
+  static fromCurve(t, e) {
+    const s = new at();
+    return s.m_Constant = 0, s.m_ConstantMin = 0, s.m_ConstantMax = 0, s.m_Curve = t, s.m_CurveMin = null, s.m_CurveMax = null, s.m_Mode = 2, s.m_CurveTimeMode = e, s;
+  }
+  /** A random value generated between two curves. */
+  static fromCurveRange(t, e, s) {
+    const i = new at();
+    return i.m_Constant = 0, i.m_ConstantMin = 0, i.m_ConstantMax = 0, i.m_Curve = null, i.m_CurveMin = t, i.m_CurveMax = e, i.m_Mode = 3, i.m_CurveTimeMode = s, i;
+  }
+  // ── Internal API ────────────────────────────────────────────────────────
+  /** @internal */
+  getValue(t, e) {
+    if (this.m_Mode === 0) return this.m_Constant;
+    if (this.m_Mode === 1)
+      return jt(this.m_ConstantMin, this.m_ConstantMax);
+    const s = this.m_CurveTimeMode === 0 ? t : e;
+    if (this.m_Mode === 2)
+      return this.m_Curve.evaluate(s);
+    if (this.m_Mode === 3)
+      return jt(
+        this.m_CurveMin.evaluate(s),
+        this.m_CurveMax.evaluate(s)
+      );
+    throw new Error("AutoTurnSettingMode not implemented");
+  }
+  /** @internal */
+  clampValues(t, e) {
+    return this.m_Constant = ot(this.m_Constant, t, e), this.m_ConstantMin = ot(this.m_ConstantMin, t, e), this.m_ConstantMax = ot(this.m_ConstantMax, t, e), this.m_Curve = this.clampCurve(this.m_Curve, t, e), this.m_CurveMin = this.clampCurve(this.m_CurveMin, t, e), this.m_CurveMax = this.clampCurve(this.m_CurveMax, t, e), this;
+  }
+  clampCurve(t, e, s) {
+    if (this.m_Curve === null || t === null) return null;
+    const i = t.keys.map((h) => ({ time: h.time, value: h.value })), r = i.length;
+    let o = 1 / 0, a = -1 / 0;
+    for (let h = 0; h < r; h++) {
+      const u = i[h].time;
+      o = Math.min(o, u), a = Math.max(a, u);
+    }
+    for (let h = 0; h < r; h++) {
+      let u = i[h].time, l = i[h].value;
+      u = ze(o, a, u), l = ot(l, e, s), i[h].time = u, i[h].value = l;
+    }
+    return new Ve(i);
+  }
+  // ── Value-type clone ────────────────────────────────────────────────────
+  clone() {
+    const t = new at();
+    return t.m_Mode = this.m_Mode, t.m_Constant = this.m_Constant, t.m_ConstantMin = this.m_ConstantMin, t.m_ConstantMax = this.m_ConstantMax, t.m_Curve = this.m_Curve, t.m_CurveMin = this.m_CurveMin, t.m_CurveMax = this.m_CurveMax, t.m_CurveTimeMode = this.m_CurveTimeMode, t;
+  }
+}
+const I = class I {
+  constructor() {
+    this.m_Mode = 0, this.m_Twist = new at(), this.m_Bend = new at(1), this.m_Duration = new at(0.5);
+  }
+  // ── Properties ──────────────────────────────────────────────────────────
+  get mode() {
+    return this.m_Mode;
+  }
+  set mode(t) {
+    this.m_Mode = t;
+  }
+  get twist() {
+    return this.m_Twist;
+  }
+  set twist(t) {
+    this.m_Twist = t.clampValues(
+      I.kMinTwist,
+      I.kMaxTwist
+    );
+  }
+  get bend() {
+    return this.m_Bend;
+  }
+  set bend(t) {
+    this.m_Bend = t.clampValues(
+      I.kMinBend,
+      I.kMaxBend
+    );
+  }
+  get duration() {
+    return this.m_Duration;
+  }
+  set duration(t) {
+    this.m_Duration = t.clampValues(
+      I.kMinDuration,
+      I.kMaxDuration
+    );
+  }
+  // ── Internal API ────────────────────────────────────────────────────────
+  /** @internal */
+  getModeValue() {
+    return this.m_Mode;
+  }
+  /** @internal */
+  getBendValue(t, e) {
+    return ot(
+      this.m_Bend.getValue(t, e),
+      I.kMinBend,
+      I.kMaxBend
+    );
+  }
+  /** @internal */
+  getDurationValue(t, e) {
+    return ot(
+      this.m_Duration.getValue(t, e),
+      I.kMinDuration,
+      I.kMaxDuration
+    );
+  }
+  /** @internal */
+  getTwistValue(t, e) {
+    return ot(
+      this.m_Twist.getValue(t, e),
+      I.kMinTwist,
+      I.kMaxTwist
+    );
+  }
+};
+I.kMinTwist = -1, I.kMaxTwist = 1, I.kMinBend = 0, I.kMaxBend = 1, I.kMinDuration = 0, I.kMaxDuration = 5;
+let ct = I, as = class extends Error {
+  constructor() {
+    super(
+      "The book's height exceeds the maximum limit. Please consider using thinner paper, increasing the width of the paper, or reducing the number of pages."
+    );
+  }
+};
+var K;
+let De = (K = class extends c.Group {
+  // ── Constructor ────────────────────────────────────────────────────────
+  constructor(t) {
+    super(), this.m_Content = null, this.m_Binding = null, this.m_InitialOpenProgress = 0, this.m_BuildOnAwake = !0, this.m_CastShadows = !0, this.m_AlignToGround = !1, this.m_HideBinder = !1, this.m_CreateColliders = !1, this.m_ReduceShadows = !1, this.m_ReduceSubMeshes = !1, this.m_ReduceOverdraw = !1, this.m_CoverPaperSetup = new lt({
+      color: new c.Color(1, 0, 0),
+      width: 2.1,
+      height: 3.1,
+      thickness: 0.04,
+      stiffness: 0.5
+    }), this.m_PagePaperSetup = new lt({
+      color: new c.Color(1, 1, 1),
+      width: 2,
+      height: 3,
+      thickness: 0.02,
+      stiffness: 0.2
+    }), this.m_Root = null, this.m_IsBuilt = !1, this.m_HasCover = !1, this.m_RendererFactory = null, this.m_MeshFactory = null, this.m_Bound = null, this.m_Papers = [], this.m_SelectedPaper = null, this.m_Direction = X.LeftToRight, this.m_AutoTurnQueue = [], this.m_AutoTurnTimer = 0, this.m_AutoTurningEndTime = -1, this.m_CurrentTime = 0, this.m_CoverPaperCount = 0, this.m_PagePaperCount = 0, this.m_TotalThickness = 0, this.m_MinPaperWidth = 0, this.m_MinPaperHeight = 0, this.m_MinPaperThickness = 0, this.m_MaxPaperThickness = 0, this.m_RendererIds = [], this.m_WasIdle = !1, t && (t.content && (this.m_Content = t.content), t.binding && (this.m_Binding = t.binding), t.initialOpenProgress !== void 0 && (this.m_InitialOpenProgress = c.MathUtils.clamp(t.initialOpenProgress, 0, 1)), t.buildOnAwake !== void 0 && (this.m_BuildOnAwake = t.buildOnAwake), t.castShadows !== void 0 && (this.m_CastShadows = t.castShadows), t.alignToGround !== void 0 && (this.m_AlignToGround = t.alignToGround), t.hideBinder !== void 0 && (this.m_HideBinder = t.hideBinder), t.createColliders !== void 0 && (this.m_CreateColliders = t.createColliders), t.reduceShadows !== void 0 && (this.m_ReduceShadows = t.reduceShadows), t.reduceSubMeshes !== void 0 && (this.m_ReduceSubMeshes = t.reduceSubMeshes), t.reduceOverdraw !== void 0 && (this.m_ReduceOverdraw = t.reduceOverdraw), t.coverPaperSetup && (this.m_CoverPaperSetup = new lt({
+      color: t.coverPaperSetup.color ?? new c.Color(1, 0, 0),
+      width: t.coverPaperSetup.width ?? 2.1,
+      height: t.coverPaperSetup.height ?? 3.1,
+      thickness: t.coverPaperSetup.thickness ?? 0.04,
+      stiffness: t.coverPaperSetup.stiffness ?? 0.5,
+      material: t.coverPaperSetup.material ?? null
+    })), t.pagePaperSetup && (this.m_PagePaperSetup = new lt({
+      color: t.pagePaperSetup.color ?? new c.Color(1, 1, 1),
+      width: t.pagePaperSetup.width ?? 2,
+      height: t.pagePaperSetup.height ?? 3,
+      thickness: t.pagePaperSetup.thickness ?? 0.02,
+      stiffness: t.pagePaperSetup.stiffness ?? 0.2,
+      material: t.pagePaperSetup.material ?? null
+    }))), K.s_Instances.add(this);
+  }
+  static get instances() {
+    return [...K.s_Instances];
+  }
+  // ── Internal accessors ─────────────────────────────────────────────────
+  get minPaperWidth() {
+    return this.m_MinPaperWidth;
+  }
+  get minPaperHeight() {
+    return this.m_MinPaperHeight;
+  }
+  get minPaperThickness() {
+    return this.m_MinPaperThickness;
+  }
+  get maxPaperThickness() {
+    return this.m_MaxPaperThickness;
+  }
+  get totalThickness() {
+    return this.m_TotalThickness;
+  }
+  get hasCover() {
+    return this.m_HasCover;
+  }
+  get castShadowsFlag() {
+    return this.m_CastShadows;
+  }
+  /** Alias matching IBookOwner interface expected by Paper.ts */
+  get castShadows() {
+    return this.m_CastShadows;
+  }
+  get alignToGround() {
+    return this.m_AlignToGround;
+  }
+  get reduceShadows() {
+    return this.m_ReduceShadows;
+  }
+  get coverPaperSetup() {
+    return this.m_CoverPaperSetup;
+  }
+  get pagePaperSetup() {
+    return this.m_PagePaperSetup;
+  }
+  get bound() {
+    return this.m_Bound;
+  }
+  get papers() {
+    return this.m_Papers;
+  }
+  get rendererIds() {
+    return this.m_RendererIds;
+  }
+  get direction() {
+    return this.m_Direction;
+  }
+  // ── Public API (properties) ────────────────────────────────────────────
+  get binding() {
+    return this.m_Binding;
+  }
+  set binding(t) {
+    this.m_Binding !== t && (this.m_Binding = t, this.clear());
+  }
+  get content() {
+    return this.m_Content;
+  }
+  set content(t) {
+    this.m_Content !== t && (this.m_Content = t, this.clear());
+  }
+  get initialOpenProgress() {
+    return this.m_InitialOpenProgress;
+  }
+  set initialOpenProgress(t) {
+    this.m_InitialOpenProgress = c.MathUtils.clamp(t, 0, 1);
+  }
+  get isBuilt() {
+    return this.m_IsBuilt;
+  }
+  get paperCount() {
+    return this.m_CoverPaperCount + this.m_PagePaperCount;
+  }
+  get coverPaperCount() {
+    return this.m_CoverPaperCount;
+  }
+  get pagePaperCount() {
+    return this.m_PagePaperCount;
+  }
+  get isTurning() {
+    return this.m_SelectedPaper !== null && this.m_SelectedPaper.isTurning;
+  }
+  get isFalling() {
+    for (const t of this.m_Papers)
+      if (t.isFalling) return !0;
+    return !1;
+  }
+  get isIdle() {
+    return !this.isTurning && !this.isFalling && !this.isAutoTurning;
+  }
+  get isAutoTurning() {
+    return this.m_AutoTurningEndTime > this.m_CurrentTime;
+  }
+  get hasPendingAutoTurns() {
+    return this.m_AutoTurnQueue.length > 0;
+  }
+  get autoTurningEndTime() {
+    return this.m_AutoTurningEndTime;
+  }
+  // ── Public API (methods) ───────────────────────────────────────────────
+  startTurning(t) {
+    if (!this.m_IsBuilt || this.isTurning) return !1;
+    const e = this.getFrontPapers();
+    for (const s of e) {
+      const i = s.raycast(t);
+      if (i.hit && i.hitInfo.pageContent.isPointOverUI(i.hitInfo.textureCoordinate))
+        return !1;
+    }
+    for (const s of e)
+      if (!s.isFalling && s.startTurning(t))
+        return this.m_SelectedPaper = s, !0;
+    return !1;
+  }
+  updateTurning(t) {
+    this.m_IsBuilt && this.m_SelectedPaper !== null && this.m_SelectedPaper.updateTurning(t);
+  }
+  stopTurning() {
+    this.m_IsBuilt && this.m_SelectedPaper !== null && (this.m_SelectedPaper.stopTurning(), this.m_SelectedPaper = null);
+  }
+  getActivePaperSideIndices(t) {
+    if (t.length = 0, !this.m_IsBuilt) return;
+    const e = this.m_Content.direction === X.RightToLeft, s = this.m_Papers.length, i = (r, o) => {
+      let a = r * 2;
+      o && a++, e && (a = s * 2 - a - 1), t.includes(a) || t.push(a);
+    };
+    for (let r = 0; r < s; r++) {
+      const o = this.m_Papers[r];
+      if (o.isFalling || o.isTurning)
+        r > 0 && i(r - 1, !0), i(r, !1), i(r, !0), r < s - 1 && i(r + 1, !1);
+      else if (o.isOnRightStack) {
+        r > 0 && i(r - 1, !0), i(r, !1);
+        break;
+      }
+    }
+    t.length === 0 && i(this.m_Papers.length - 1, !0), e && t.reverse();
+  }
+  setOpenProgress(t) {
+    this.cancelPendingAutoTurns(), this.m_Content.direction % 2 !== 0 && (t = 1 - t);
+    const e = this.m_Papers.length, s = Math.round(c.MathUtils.lerp(0, e, t));
+    for (let i = 0; i < e; i++) {
+      const r = i >= s;
+      this.m_Papers[i].restState(r);
+    }
+    for (let i = 0; i < e; i++)
+      this.m_Papers[i].restMesh();
+    this.m_WasIdle = !1;
+  }
+  setOpenProgressByIndex(t) {
+    const e = this.m_Content.convertPaperSideIndexToOpenProgress(t);
+    this.setOpenProgress(e);
+  }
+  // ── Auto Turning ──────────────────────────────────────────────────────
+  startAutoTurning(t, e, s = 1, i = 0) {
+    if (!this.m_IsBuilt) return !1;
+    this.cancelPendingAutoTurns();
+    const r = typeof i == "number" ? new at(i) : i;
+    if (s = Math.min(s, this.getMaxAutoTurnCount(t)), s === 0) return !1;
+    for (let o = 0; o < s && this.canAutoTurn(t); o++) {
+      const a = o / (s - 1 || 1), h = this.getAutoTurnPaperIndexTime(t), u = o > 0 ? r.getValue(h, a) : 0, l = e.getModeValue(), d = e.getTwistValue(h, a), p = e.getBendValue(h, a), g = e.getDurationValue(h, a);
+      this.m_AutoTurnQueue.push({ direction: t, mode: l, twist: d, bend: p, duration: g, delay: u });
+    }
+    return this.m_AutoTurnTimer = 0, !0;
+  }
+  cancelPendingAutoTurns() {
+    this.m_AutoTurnQueue.length = 0;
+  }
+  processAutoTurnQueue(t) {
+    if (this.m_AutoTurnQueue.length === 0 || (this.m_AutoTurnTimer -= t, this.m_AutoTurnTimer > 0)) return;
+    const e = this.m_AutoTurnQueue[0];
+    if (!this.canAutoTurn(e.direction)) {
+      this.m_AutoTurnQueue.length = 0;
+      return;
+    }
+    const s = this.getAutoTurnPaper(e.direction);
+    if (s === null) {
+      this.m_AutoTurnQueue.length = 0;
+      return;
+    }
+    s.startAutoTurning(e.mode, e.twist, e.bend, e.duration), this.m_AutoTurningEndTime = Math.max(
+      this.m_AutoTurningEndTime,
+      this.m_CurrentTime + e.duration
+    ), this.m_AutoTurnQueue.shift(), this.m_AutoTurnQueue.length > 0 && (this.m_AutoTurnTimer = this.m_AutoTurnQueue[0].delay);
+  }
+  getAutoTurnPaper(t) {
+    if (this.isTurning) return null;
+    const e = this.getFrontPapers();
+    if (e.length > 0) {
+      const s = t === dt.Next, i = e[s ? e.length - 1 : 0];
+      if (!i.isTurning && !i.isFalling && s === i.isOnRightStack)
+        return i;
+    }
+    return null;
+  }
+  getMaxAutoTurnCount(t) {
+    const e = this.getAutoTurnPaper(t);
+    if (e === null) return 0;
+    let s = 1;
+    return t === dt.Next ? s += this.m_Papers.length - e.index - 1 : s += e.index, s;
+  }
+  canAutoTurn(t) {
+    return this.getAutoTurnPaper(t) !== null;
+  }
+  getAutoTurnPaperIndexTime(t) {
+    const e = this.getAutoTurnPaper(t);
+    return e === null ? 0 : e.index / (this.m_Papers.length - 1 || 1);
+  }
+  // ── Lifecycle ─────────────────────────────────────────────────────────
+  /**
+   * Initialize the book. Call this after adding to scene.
+   * Equivalent to Unity's Start/Awake.
+   */
+  init() {
+    K.s_Instances.add(this), this.hardClear(), this.m_BuildOnAwake && this.build();
+  }
+  /**
+   * Call every frame with delta time.
+   * Equivalent to Unity's LateUpdate.
+   */
+  update(t) {
+    if (this.m_CurrentTime += t, !!this.m_IsBuilt && this.m_Papers.length !== 0 && this.m_Bound !== null && (this.processAutoTurnQueue(t), !(this.m_WasIdle && this.isIdle))) {
+      this.m_WasIdle = this.isIdle;
+      for (const e of this.m_Papers)
+        e.isFalling && e.updateFalling(t);
+      this.updateLivePages(), this.m_Bound.onLateUpdate();
+    }
+  }
+  dispose() {
+    K.s_Instances.delete(this), this.hardClear();
+  }
+  // ── Build ─────────────────────────────────────────────────────────────
+  build() {
+    if (this.clear(), this.m_Content === null || this.m_Content.isEmpty || this.m_Binding === null) return;
+    if (this.m_MeshFactory === null && (this.m_MeshFactory = new we()), this.m_RendererFactory === null) {
+      const C = new c.Object3D();
+      C.name = "Root", this.add(C), this.m_Root = C, this.m_RendererFactory = new Se(this.m_Root);
+    }
+    this.m_RendererFactory.createColliders = this.m_CreateColliders, this.m_Direction = this.m_Content.direction;
+    const t = this.m_Direction > 1 ? Math.PI / 2 : 0;
+    this.m_Root.rotation.set(0, t, 0), this.m_CoverPaperSetup.bookDirection = this.m_Content.direction, this.m_PagePaperSetup.bookDirection = this.m_Content.direction, this.m_PagePaperSetup.height < this.m_CoverPaperSetup.height ? (this.m_CoverPaperSetup.margin = 0, this.m_PagePaperSetup.margin = (this.m_CoverPaperSetup.height - this.m_PagePaperSetup.height) / 2) : (this.m_CoverPaperSetup.margin = (this.m_PagePaperSetup.height - this.m_CoverPaperSetup.height) / 2, this.m_PagePaperSetup.margin = 0);
+    const e = new Ht(this.m_CoverPaperSetup), s = new Ht(this.m_PagePaperSetup);
+    this.m_Content.init(this);
+    let i = this.m_Content.coverContents, r = this.m_Content.pageContents, o = this.m_InitialOpenProgress;
+    this.m_Content.direction % 2 !== 0 && (i = [...i].reverse(), r = [...r].reverse(), o = 1 - o), this.m_HasCover = i.length > 0, this.m_CoverPaperCount = Math.floor(i.length / 2), this.m_PagePaperCount = Math.floor(r.length / 2);
+    const a = this.m_CoverPaperCount + this.m_PagePaperCount, h = Math.floor(i.length / 4);
+    let u = 0, l = 0, d = 0;
+    this.m_Papers = new Array(a);
+    for (let C = 0; C < a; C++) {
+      const R = this.m_HasCover && (C < h || C >= a - h), L = this.m_RendererFactory.get("Paper"), v = this.m_Papers[C] = new fe(R, C, this, L);
+      v.renderer.castShadows = this.m_CastShadows, C < Math.round(c.MathUtils.lerp(0, a, o)) && (v.transform.scale.set(-1, 1, 1), v.setTime(1)), R ? (v.setContentData(i[l++], i[l++], C > h), v.setMaterialData(e), v.setPaperSetup(this.m_CoverPaperSetup)) : (v.setContentData(r[u++], r[u++]), v.setMaterialData(s), v.setPaperSetup(this.m_PagePaperSetup)), d += v.thickness;
+    }
+    this.m_TotalThickness = d;
+    const p = this.m_Papers[0].thickness, g = this.m_Papers[Math.floor(a / 2)].thickness;
+    this.m_MinPaperThickness = Math.min(p, g), this.m_MaxPaperThickness = Math.max(p, g);
+    const m = this.m_Papers[0].size.x, _ = this.m_Papers[Math.floor(a / 2)].size.x;
+    this.m_MinPaperWidth = Math.min(m, _);
+    const f = this.m_Papers[0].size.y, T = this.m_Papers[Math.floor(a / 2)].size.y;
+    this.m_MinPaperHeight = Math.min(f, T), this.m_Bound = this.m_Binding.createBound(
+      this,
+      this.m_Root,
+      this.m_RendererFactory,
+      this.m_MeshFactory
+    ), this.m_Bound.binderRenderer.setVisibility(!this.m_HideBinder);
+    const b = this.m_ReduceOverdraw && r.length > 0, x = this.m_ReduceSubMeshes, P = this.createPaperMeshDataPool(this.m_PagePaperSetup, !0, x), S = b ? this.createPaperMeshDataPool(this.m_PagePaperSetup, !0, x, !0) : null, k = this.createPaperMeshDataPool(this.m_PagePaperSetup, !1), O = this.createPaperMeshDataPool(this.m_CoverPaperSetup, !0), Z = this.createPaperMeshDataPool(this.m_CoverPaperSetup, !1), z = Math.floor(a / 2) - 1, N = z + 1, D = this.m_Bound.constructor.name.includes("Staple");
+    for (let C = 0; C < a; C++) {
+      const R = this.m_Papers[C];
+      C !== 0 && (R.prev = this.m_Papers[C - 1]), C !== a - 1 && (R.next = this.m_Papers[C + 1]), R.noHole = D && (C === z || C === N), R.isCover ? R.setMeshData(O.get(), null, Z) : R.setMeshData(
+        P.get(),
+        (S == null ? void 0 : S.get()) ?? null,
+        k
+      );
+    }
+    this.m_IsBuilt = !0, this.m_RendererIds = this.m_RendererFactory.ids, this.update(0), this.m_Bound.binderRenderer.updateCollider(), this.m_CoverPaperSetup.bookDirection = X.LeftToRight, this.m_PagePaperSetup.bookDirection = X.LeftToRight;
+  }
+  clear() {
+    return this.m_CoverPaperCount = this.m_PagePaperCount = 0, this.m_IsBuilt = !1, this.m_WasIdle = !1, this.m_Bound = null, this.m_MeshFactory !== null && this.m_MeshFactory.recycle(), this.m_RendererFactory !== null && this.m_RendererFactory.recycle(), this;
+  }
+  hardClear() {
+    this.m_CoverPaperCount = this.m_PagePaperCount = 0, this.m_IsBuilt = !1, this.m_WasIdle = !1, this.m_Bound = null, this.m_Root !== null && (this.remove(this.m_Root), this.m_Root = null), this.m_MeshFactory !== null && (this.m_MeshFactory.destroy(), this.m_MeshFactory = null), this.m_RendererFactory !== null && (this.m_RendererFactory.destroy(), this.m_RendererFactory = null);
+  }
+  createPaperMeshDataPool(t, e, s = !1, i = !1) {
+    const r = e ? 0 : t.quality, o = this.m_Bound.createPaperPattern(
+      r,
+      t.size,
+      t.thickness,
+      t.uvMargin,
+      i,
+      s
+    );
+    return new Be(
+      this.m_MeshFactory,
+      o,
+      e && this.m_Bound.useSharedMeshDataForLowpoly
+    );
+  }
+  // ── Query methods ─────────────────────────────────────────────────────
+  getFrontPapers() {
+    const t = [];
+    if (this.m_SelectedPaper !== null) {
+      const e = this.m_SelectedPaper.index;
+      e > 0 && t.push(this.m_Papers[e - 1]), t.push(this.m_SelectedPaper), e < this.m_Papers.length - 1 && t.push(this.m_Papers[e + 1]);
+    } else {
+      for (let e = 0; e < this.m_Papers.length; e++)
+        if (this.m_Papers[e].isOnRightStack) {
+          e > 0 && t.push(this.m_Papers[e - 1]), t.push(this.m_Papers[e]);
+          break;
+        }
+      t.length === 0 && t.push(this.m_Papers[this.m_Papers.length - 1]);
+    }
+    return t;
+  }
+  getAverageTime() {
+    const t = this.m_Papers.length;
+    let e = 0;
+    for (const s of this.m_Papers)
+      s.updateTime(), e += s.zTime;
+    return e /= t, e;
+  }
+  bookRaycast(t) {
+    const e = this.getFrontPapers();
+    for (const s of e) {
+      const i = s.raycast(t);
+      if (i.hit) return i.hitInfo;
+    }
+    return null;
+  }
+  // ── Live Pages ────────────────────────────────────────────────────────
+  updateLivePages() {
+    const t = /* @__PURE__ */ new Set(), e = this.m_Papers.length;
+    for (let s = 0; s < e; s++) {
+      const i = this.m_Papers[s];
+      if (i.isFalling || i.isTurning)
+        s > 0 && t.add(this.m_Papers[s - 1].backContent), t.add(i.frontContent), t.add(i.backContent), s < e - 1 && t.add(this.m_Papers[s + 1].frontContent);
+      else if (i.isOnRightStack) {
+        s > 0 && t.add(this.m_Papers[s - 1].backContent), t.add(i.frontContent);
+        break;
+      }
+    }
+    t.size === 0 && t.add(this.m_Papers[this.m_Papers.length - 1].backContent);
+    for (const s of this.m_Papers)
+      s.frontContent.setActive(t.has(s.frontContent)), s.backContent.setActive(t.has(s.backContent));
+  }
+}, K.s_Instances = /* @__PURE__ */ new Set(), K);
+function Ae(n, t, e) {
+  const s = ut(null), [i, r] = $t(!1);
+  return Tt(() => {
+    const o = new De(n);
+    s.current = o;
+    try {
+      o.init(), r(!0), t == null || t(o);
+    } catch (a) {
+      e == null || e(a);
+    }
+    return () => {
+      o.dispose(), s.current = null, r(!1);
+    };
+  }, []), Kt((o, a) => {
+    var h;
+    (h = s.current) == null || h.update(a);
+  }), { bookRef: s, ready: i };
+}
+const vt = ne(null);
+function Ct() {
+  return Yt(vt);
+}
+function ls() {
+  const n = Yt(vt);
+  if (!n)
+    throw new Error("useRequiredBook() must be called inside a <Book> component.");
+  return n;
+}
+const cs = re(function({ onBuilt: t, onError: e, children: s, ...i }, r) {
+  const { bookRef: o, ready: a } = Ae(i, t, e);
+  return oe(r, () => o.current, [a]), !a || !o.current ? null : /* @__PURE__ */ se(vt.Provider, { value: o.current, children: [
+    /* @__PURE__ */ ie("primitive", { object: o.current }),
+    s
+  ] });
+});
+function Fe(n, { enabled: t = !0, orbitControlsRef: e } = {}) {
+  const { gl: s, camera: i } = he(), r = ut(!1), o = ut(null), a = ut(t);
+  a.current = t, Tt(() => {
+    const h = s.domElement, u = new c.Raycaster(), l = new c.Vector2(), d = (_) => {
+      const f = h.getBoundingClientRect();
+      return l.set(
+        (_.clientX - f.left) / f.width * 2 - 1,
+        -((_.clientY - f.top) / f.height) * 2 + 1
+      ), u.setFromCamera(l, i), u.ray;
+    }, p = (_) => {
+      if (!a.current || _.button !== 0) return;
+      r.current = !0;
+      const f = n.current;
+      f && f.startTurning(d(_)) && (o.current = f, e != null && e.current && (e.current.enabled = !1));
+    }, g = (_) => {
+      !r.current || !o.current || o.current.updateTurning(d(_));
+    }, m = () => {
+      r.current = !1, o.current && (o.current.stopTurning(), o.current = null, e != null && e.current && (e.current.enabled = !0));
+    };
+    return h.addEventListener("pointerdown", p), h.addEventListener("pointermove", g), h.addEventListener("pointerup", m), () => {
+      h.removeEventListener("pointerdown", p), h.removeEventListener("pointermove", g), h.removeEventListener("pointerup", m);
+    };
+  }, [s, i, n, e]);
+}
+function us({ bookRef: n, enabled: t = !0, orbitControlsRef: e }) {
+  const s = Ct(), i = ut(null);
+  return i.current = (n == null ? void 0 : n.current) ?? s, Fe(i, { enabled: t, orbitControlsRef: e }), null;
+}
+function ms(n) {
+  const t = Ct(), e = rt(
+    (r) => {
+      var o;
+      return (o = (n == null ? void 0 : n.current) ?? t) == null ? void 0 : o.setOpenProgress(r);
+    },
+    [n, t]
+  ), s = rt(
+    (r) => {
+      var o;
+      return (o = (n == null ? void 0 : n.current) ?? t) == null ? void 0 : o.setOpenProgressByIndex(r);
+    },
+    [n, t]
+  ), i = rt(
+    () => {
+      var r;
+      return (r = (n == null ? void 0 : n.current) ?? t) == null ? void 0 : r.stopTurning();
+    },
+    [n, t]
+  );
+  return { setOpenProgress: e, setOpenProgressByIndex: s, stopTurning: i };
+}
+function ds(n) {
+  const t = Ct(), e = () => (n == null ? void 0 : n.current) ?? t, s = rt(
+    (h) => {
+      var u;
+      return ((u = e()) == null ? void 0 : u.startAutoTurning(dt.Next, h ?? new ct(), 1)) ?? !1;
+    },
+    [n, t]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), i = rt(
+    (h) => {
+      var u;
+      return ((u = e()) == null ? void 0 : u.startAutoTurning(dt.Back, h ?? new ct(), 1)) ?? !1;
+    },
+    [n, t]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), r = rt(
+    (h, u) => {
+      const l = e();
+      return l ? l.startAutoTurning(h, u ?? new ct(), l.paperCount) : !1;
+    },
+    [n, t]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), o = rt(
+    (h, u = new ct(), l = 1, d = 0) => {
+      var p;
+      return ((p = e()) == null ? void 0 : p.startAutoTurning(h, u, l, d)) ?? !1;
+    },
+    [n, t]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  ), a = rt(
+    () => {
+      var h;
+      return (h = e()) == null ? void 0 : h.cancelPendingAutoTurns();
+    },
+    [n, t]
+    // eslint-disable-line react-hooks/exhaustive-deps
+  );
+  return { turnNext: s, turnPrev: i, turnAll: r, startAutoTurning: o, cancelPendingAutoTurns: a };
+}
+const He = {
+  isBuilt: !1,
+  isTurning: !1,
+  isFalling: !1,
+  isIdle: !0,
+  isAutoTurning: !1,
+  hasPendingAutoTurns: !1,
+  paperCount: 0,
+  coverPaperCount: 0,
+  pagePaperCount: 0
+};
+function Oe(n) {
+  return {
+    isBuilt: n.isBuilt,
+    isTurning: n.isTurning,
+    isFalling: n.isFalling,
+    isIdle: n.isIdle,
+    isAutoTurning: n.isAutoTurning,
+    hasPendingAutoTurns: n.hasPendingAutoTurns,
+    paperCount: n.paperCount,
+    coverPaperCount: n.coverPaperCount,
+    pagePaperCount: n.pagePaperCount
+  };
+}
+function Ze(n, t) {
+  return n.isBuilt === t.isBuilt && n.isTurning === t.isTurning && n.isFalling === t.isFalling && n.isIdle === t.isIdle && n.isAutoTurning === t.isAutoTurning && n.hasPendingAutoTurns === t.hasPendingAutoTurns && n.paperCount === t.paperCount && n.coverPaperCount === t.coverPaperCount && n.pagePaperCount === t.pagePaperCount;
+}
+function _s(n) {
+  const t = Ct(), [e, s] = $t(He);
+  return Kt(() => {
+    const i = (n == null ? void 0 : n.current) ?? t;
+    if (!i) return;
+    const r = Oe(i);
+    s((o) => Ze(o, r) ? o : r);
+  }), e;
+}
+function Ne(n) {
+  return [...n.covers, ...n.pages].filter((e) => e instanceof c.Texture);
+}
+function gs(n, t) {
+  const e = ut([]), s = ae(() => {
+    for (const r of e.current) r.dispose();
+    const i = n();
+    return e.current = Ne(i), i;
+  }, t);
+  return Tt(() => () => {
+    for (const i of e.current) i.dispose();
+  }, []), s;
+}
+function Le(n, t, e, s, i, r, o) {
+  const a = t.naturalWidth || t.width, h = t.naturalHeight || t.height;
+  if (a <= 0 || h <= 0) return;
+  if (o === "fill") {
+    n.drawImage(t, e, s, i, r);
+    return;
+  }
+  const u = o === "contain" ? Math.min(i / a, r / h) : Math.max(i / a, r / h), l = a * u, d = h * u;
+  n.drawImage(t, e + (i - l) * 0.5, s + (r - d) * 0.5, l, d);
+}
+function ps(n, t, e, s, i) {
+  const r = document.createElement("canvas");
+  r.width = 512, r.height = 512;
+  const o = r.getContext("2d");
+  if (o.fillStyle = n, o.fillRect(0, 0, 512, 512), e) {
+    const h = i ? 0 : 56;
+    Le(o, e, h, h, 512 - h * 2, 512 - h * 2, s);
+  } else
+    o.fillStyle = "#333", o.font = "bold 48px Arial", o.textAlign = "center", o.textBaseline = "middle", o.fillText(t, 256, 256);
+  const a = new c.CanvasTexture(r);
+  return a.colorSpace = c.SRGBColorSpace, a;
+}
+async function fs(n) {
+  if (!n) return null;
+  const t = URL.createObjectURL(n), e = new Image();
+  e.decoding = "async", e.src = t;
+  try {
+    return await new Promise((s, i) => {
+      e.onload = () => s(), e.onerror = () => i(new Error(`Failed to decode image: ${n.name}`));
+    }), { image: e, objectUrl: t };
+  } catch (s) {
+    return URL.revokeObjectURL(t), console.error(s), null;
+  }
+}
+class Ms {
+  constructor() {
+    this.m_BookContent = null, this.m_IsActive = !1, this.onActiveChangedCallback = null;
+  }
+  get bookContent() {
+    return this.m_BookContent;
+  }
+  get isActive() {
+    return this.m_IsActive;
+  }
+  get textureST() {
+    return new c.Vector4(1, 1, 0, 0);
+  }
+  get isShareable() {
+    return !0;
+  }
+  onInit() {
+  }
+  onActiveChanged() {
+  }
+  onIsPointOverUI(t) {
+    return !1;
+  }
+  isPointOverUI(t) {
+    return this.onIsPointOverUI(t);
+  }
+  init(t) {
+    var e;
+    !this.isShareable && this.m_BookContent !== null && this.m_BookContent !== t && (console.error("The page content is already in use. It can only be assigned to one book content."), (e = this.m_BookContent.book) == null || e.clear()), this.m_BookContent = t, this.m_IsActive = !1, this.onInit();
+  }
+  setActive(t) {
+    var e;
+    this.m_IsActive !== t && (this.m_IsActive = t, this.onActiveChanged(), (e = this.onActiveChangedCallback) == null || e.call(this));
+  }
+}
+class qt {
+  constructor(t, e) {
+    this.m_Texture = t, this.m_TextureST = e ?? new c.Vector4(1, 1, 0, 0);
+  }
+  get texture() {
+    return this.m_Texture;
+  }
+  get textureST() {
+    return this.m_Texture ? this.m_TextureST : new c.Vector4(1, 1, 0, 0);
+  }
+  isPointOverUI(t) {
+    return !1;
+  }
+  init(t) {
+  }
+  setActive(t) {
+  }
+}
+class xs {
+  constructor() {
+    this.m_Direction = X.LeftToRight, this.m_Covers = [null, null, null, null], this.m_Pages = [null, null, null, null, null, null, null, null], this.m_Book = null;
+  }
+  get coverCount4() {
+    return this.nextMultipleOf4(this.m_Covers.length);
+  }
+  get pageCount4() {
+    return this.nextMultipleOf4(this.m_Pages.length);
+  }
+  get book() {
+    return this.m_Book;
+  }
+  get covers() {
+    return this.m_Covers;
+  }
+  get pages() {
+    return this.m_Pages;
+  }
+  get isEmpty() {
+    return this.m_Covers.length === 0 && this.m_Pages.length === 0;
+  }
+  get direction() {
+    return this.m_Direction;
+  }
+  set direction(t) {
+    this.m_Direction = t;
+  }
+  get coverContents() {
+    return this.getContents(this.m_Covers, !1);
+  }
+  get pageContents() {
+    return this.getContents(this.m_Pages, !1);
+  }
+  getContents(t, e) {
+    const s = t.length;
+    let i = this.nextMultipleOf4(s);
+    e && (i = Math.min(i, 4));
+    const r = new Array(i);
+    for (let o = 0; o < i; o++)
+      r[o] = this.getContent(o < s ? t[o] : null);
+    return r;
+  }
+  nextMultipleOf4(t) {
+    return Math.ceil(t / 4) * 4;
+  }
+  getContent(t) {
+    if (t !== null) {
+      if (t instanceof c.Texture)
+        return new qt(t);
+      if (typeof t.init == "function")
+        return t;
+    }
+    return new qt(null);
+  }
+  init(t) {
+    this.m_Book = t;
+    for (const e of this.coverContents)
+      e.init(this);
+    for (const e of this.pageContents)
+      e.init(this);
+  }
+  // ── Index conversion methods ───────────────────────────────────────────
+  convertCoverIndexToPaperSideIndex(t) {
+    if (this.m_Covers.length === 0)
+      throw new Error("Check covers.length > 0 before calling this method.");
+    return this.m_Pages.length === 0 || t < this.coverCount4 / 2 ? t : t + this.pageCount4;
+  }
+  convertPageIndexToPaperSideIndex(t) {
+    if (this.m_Pages.length === 0)
+      throw new Error("Check pages.length > 0 before calling this method.");
+    return this.m_Covers.length === 0 ? t : t + this.coverCount4 / 2;
+  }
+  convertPaperSideIndexToCoverIndex(t) {
+    if (this.m_Covers.length === 0)
+      throw new Error("Check covers.length > 0 before calling this method.");
+    if (this.isPagePaperSideIndex(t))
+      throw new Error("Check isCoverPaperSideIndex before calling this method.");
+    return t > this.coverCount4 / 2 ? t - this.pageCount4 : t;
+  }
+  convertPaperSideIndexToPageIndex(t) {
+    if (this.m_Pages.length === 0)
+      throw new Error("Check pages.length > 0 before calling this method.");
+    if (this.isCoverPaperSideIndex(t))
+      throw new Error("Check isPagePaperSideIndex before calling this method.");
+    return t - this.coverCount4 / 2;
+  }
+  convertPaperSideIndexToOpenProgress(t) {
+    return t / (this.coverCount4 + this.pageCount4 - 1);
+  }
+  isCoverPaperSideIndex(t) {
+    const e = this.coverCount4 / 2, s = this.pageCount4 / 2;
+    if (e === 0) return !1;
+    if (s === 0) return !0;
+    const i = e, r = e + s * 2 - 1;
+    return t < i || t > r;
+  }
+  isPagePaperSideIndex(t) {
+    return !this.isCoverPaperSideIndex(t);
+  }
+}
+class Ue {
+}
+class Cs {
+  constructor(t, e) {
+    this.m_Book = t, this.m_Root = e;
+  }
+}
+function Gt(n, t, e, s) {
+  const i = 1 - s;
+  return new c.Vector3(
+    i * i * n.x + 2 * i * s * t.x + s * s * e.x,
+    i * i * n.y + 2 * i * s * t.y + s * s * e.y,
+    i * i * n.z + 2 * i * s * t.z + s * s * e.z
+  );
+}
+function Wt(n, t) {
+  return n++, n === t ? 0 : n;
+}
+function Ee(n, t) {
+  return n === 0 ? t - 1 : n - 1;
+}
+class Xe {
+  constructor() {
+    this.baseXArray = [], this.baseZArray = [], this.baseXOffset = 0, this.baseVertexCount = 0, this.xSeams = [], this.zSeams = [], this.xNoneSeamIndexes = [], this.borders = [], this.texcoords = [], this.weights = [], this.triangles = [], this.frontTriangles = [], this.backTriangles = [], this.borderTriangles = [], this.vertexCount = 0, this.subMeshCount = 0, this.size = new c.Vector2(), this.thickness = 0;
+  }
+}
+const je = 0.01, qe = 0.1, Ge = 0.04, We = 0.4, Qe = 2, $e = 10, Ye = 0, Ke = 5;
+function st(n, t, e) {
+  return Math.max(t, Math.min(e, n));
+}
+function te(n) {
+  return Math.max(0, Math.min(1, n));
+}
+function H(n, t, e) {
+  return n + (t - n) * e;
+}
+function Qt(n, t, e) {
+  return n === t ? 0 : te((e - n) / (t - n));
+}
+function Je(n, t) {
+  const e = n.clone().normalize();
+  if (e.lengthSq() === 0) return new c.Quaternion();
+  let s = new c.Vector3().crossVectors(t, e);
+  if (s.lengthSq() === 0) {
+    const o = Math.abs(e.y) < 0.999 ? new c.Vector3(0, 1, 0) : new c.Vector3(1, 0, 0);
+    s = new c.Vector3().crossVectors(o, e);
+  }
+  s.normalize();
+  const i = new c.Vector3().crossVectors(e, s).normalize(), r = new c.Matrix4().makeBasis(s, i, e);
+  return new c.Quaternion().setFromRotationMatrix(r);
+}
+const et = Math.PI / 180, nt = 180 / Math.PI;
+class ts {
+  constructor() {
+    this._material = null, this._color = new c.Color(1, 1, 1), this._thickness = 0.05, this._crown = 0.2, this._margin = 0.1, this._count = 4, this._quality = 3;
+  }
+  get material() {
+    return this._material;
+  }
+  set material(t) {
+    this._material = t;
+  }
+  get color() {
+    return this._color;
+  }
+  set color(t) {
+    this._color = t;
+  }
+  get thickness() {
+    return this._thickness;
+  }
+  set thickness(t) {
+    this._thickness = st(t, je, qe);
+  }
+  get margin() {
+    return this._margin;
+  }
+  set margin(t) {
+    this._margin = te(t);
+  }
+  get crown() {
+    return this._crown;
+  }
+  set crown(t) {
+    this._crown = st(t, Ge, We);
+  }
+  get count() {
+    return this._count;
+  }
+  set count(t) {
+    this._count = st(t, Qe, $e);
+  }
+  get quality() {
+    return this._quality;
+  }
+  set quality(t) {
+    this._quality = st(t, Ye, Ke);
+  }
+}
+class es extends Error {
+  constructor() {
+    super("Book height is too large relative to paper width."), this.name = "BookHeightException";
+  }
+}
+class ss {
+  // ── Constructor ────────────────────────────────────────────────────────
+  constructor(t, e, s, i, r) {
+    if (this.m_StapleMargin = 0, this.m_StapleThickness = 0, this.m_BindingRadius = 0, this.m_BindingMidSpace = 0, this.m_StackHeight = 0, this.m_BindingVertexCount = 0, this.useSharedMeshDataForLowpoly = !1, this._binderRendererAdapter = null, this.m_Book = s, this.m_Root = i, this.m_Quality = t, s.totalThickness * 1.25 > s.minPaperWidth)
+      throw new es();
+    const o = this.m_Book.coverPaperSetup, a = this.m_Book.pagePaperSetup, h = new c.BufferGeometry();
+    this.updateStapleMesh(e, h);
+    const u = r ?? new c.MeshStandardMaterial({
+      color: e.color,
+      metalness: 0.9,
+      roughness: 0.3
+    });
+    this.stapleMesh = new c.Mesh(h, u), this.stapleMesh.name = "Staple", this.stapleMesh.castShadow = this.m_Book.castShadows, i.add(this.stapleMesh), this.stapleMesh.position.set(
+      0,
+      0,
+      this.m_StapleMargin + a.margin + o.margin
+    );
+    let l = o.thickness;
+    l = Math.max(this.m_BindingRadius, l);
+    for (const d of this.m_Book.papers) {
+      const p = d.size.clone();
+      p.x -= this.m_BindingRadius, d.sizeXOffset = this.m_BindingRadius, d.size = p, d.setMinTurningRadius(l), d.updateTurningRadius(), this.updatePaperPosition(d);
+    }
+    this.updateRootPosition();
+  }
+  get binderRenderer() {
+    return this._binderRendererAdapter || (this._binderRendererAdapter = new is(this.stapleMesh)), this._binderRendererAdapter;
+  }
+  // ── updateStapleMesh ──────────────────────────────────────────────────
+  updateStapleMesh(t, e) {
+    this.m_StapleThickness = t.thickness, this.m_StackHeight = this.m_Book.totalThickness, this.m_BindingMidSpace = this.m_StapleThickness * 1.75, this.m_BindingRadius = (this.m_StackHeight + this.m_BindingMidSpace) / 2 / Math.sin(45 * et), this.m_StackHeight += this.m_BindingMidSpace;
+    let s = t.crown;
+    s = Math.max(s, this.m_StapleThickness * 4);
+    const i = this.m_StapleThickness * 0.5, r = Math.max(
+      this.m_Book.minPaperHeight / 2 - s - i,
+      i
+    );
+    this.m_StapleMargin = H(i, r, t.margin);
+    const o = this.m_Book.minPaperHeight - this.m_StapleMargin * 2;
+    let a = t.count, h = (o - s * a) / (a - 1);
+    for (h = Math.max(h, 0); h < this.m_StapleThickness * 2 && a > 2; )
+      a--, h = (o - s * a) / (a - 1), h = Math.max(h, 0);
+    const u = t.quality / 5, l = Math.floor(H(4, 20, u)), d = Math.floor(H(4, 10, u)), p = Math.floor(H(3, 10, u)), g = this.m_StapleThickness / 2, m = g * 2.5, _ = 0.9, f = g * 1;
+    let T = s / 2 * _;
+    T = Math.max(T, f * 2);
+    let b = 0;
+    b += this.m_Book.totalThickness / 2, b += g;
+    const x = -(this.m_Book.papers[0].thickness / 2 + g), P = [];
+    {
+      for (let V = 0; V < d; V++) {
+        const E = V / (d - 1), W = H(-90, -180, E) * et, y = new c.Vector3(
+          f * Math.sin(W),
+          0,
+          f * Math.cos(W)
+        );
+        y.x += f, y.z += f, y.x += x, P.push(y);
+      }
+      const M = new c.Vector3(b, 0, 0), F = new c.Vector3(b + m * 0.75, 0, 0), w = new c.Vector3(b - g * 0.5, 0, T);
+      for (let V = 0; V < p; V++) {
+        const E = V / (p - 1), G = Gt(M, F, w, E);
+        G.x += x, P.push(G);
+      }
+      P.reverse();
+    }
+    const S = new Array(l);
+    for (let M = 0; M < l; M++) {
+      const w = (90 - M * (360 / l)) * et;
+      S[M] = new c.Vector3(Math.cos(w), Math.sin(w), 0), S[M].x *= 0.75;
+    }
+    const k = P.length, O = k * l, Z = new Array(O * 2), z = new Array(O * 2), N = new Array(
+      (O * 2 - 1) * l * 2 * 3
+    );
+    for (let M = 0; M < O * 2; M++)
+      Z[M] = new c.Vector3(), z[M] = new c.Vector3();
+    let D = 0;
+    for (let M = 0; M < k; M++) {
+      const F = P[Ee(M, k)], w = P[M], V = P[Wt(M, k)];
+      let E;
+      if (M === 0)
+        E = new c.Vector3(1, 0, -2).normalize();
+      else if (M === k - 1)
+        E = new c.Vector3(0, 0, 1);
+      else {
+        const J = w.clone().sub(F).normalize(), tt = V.clone().sub(w).normalize();
+        E = J.add(tt).multiplyScalar(0.5);
+      }
+      const G = new c.Vector3(0, 1, 0), W = Je(E, G), y = D;
+      let B = Qt(0, p / 4, M);
+      B = H(0.1, 1, B), B = Math.sqrt(B);
+      for (let J = 0; J < l; J++) {
+        const tt = S[J].clone().applyQuaternion(W).multiplyScalar(B), _t = w.clone().add(tt.clone().multiplyScalar(g));
+        Z[D] = _t, z[D] = tt.clone();
+        const ht = w.clone().add(tt.clone().multiplyScalar(g));
+        ht.z = s - ht.z;
+        const ee = y + l - J - 1, kt = O * 2 - ee - 1;
+        Z[kt] = ht, z[kt] = tt.clone(), D++;
+      }
+    }
+    let C = 0;
+    const R = P.length * 2;
+    for (let M = 0; M < R - 1; M++) {
+      const F = M * l, w = (M + 1) * l;
+      for (let V = 0; V < l; V++) {
+        const E = Wt(V, l), G = F + V, W = F + E, y = w + E, B = w + V;
+        N[C++] = G, N[C++] = B, N[C++] = W, N[C++] = W, N[C++] = B, N[C++] = y;
+      }
+    }
+    const L = [...Z], v = [...z], Q = [...N], q = Z.map((M) => M.clone()), $ = [...N];
+    for (let M = 0; M < a - 1; M++) {
+      const F = q.length;
+      for (let w = 0; w < $.length; w++)
+        $[w] += F;
+      for (let w = 0; w < q.length; w++)
+        q[w].z += h + s;
+      L.push(...q.map((w) => w.clone())), v.push(...z.map((w) => w.clone())), Q.push(...$);
+    }
+    const j = new Float32Array(L.length * 3), A = new Float32Array(v.length * 3);
+    for (let M = 0; M < L.length; M++)
+      j[M * 3] = L[M].x, j[M * 3 + 1] = L[M].y, j[M * 3 + 2] = L[M].z, A[M * 3] = v[M].x, A[M * 3 + 1] = v[M].y, A[M * 3 + 2] = v[M].z;
+    e.setAttribute(
+      "position",
+      new c.BufferAttribute(j, 3)
+    ), e.setAttribute(
+      "normal",
+      new c.BufferAttribute(A, 3)
+    ), e.setIndex(Q);
+  }
+  // ── createPaperPattern ────────────────────────────────────────────────
+  createPaperPattern(t, e, s, i, r, o) {
+    const a = new Xe();
+    a.size = e, a.thickness = s;
+    const h = this.m_BindingRadius;
+    a.baseXOffset = -h;
+    const u = this.m_Quality + 1;
+    this.m_BindingVertexCount = u;
+    const l = t / 5, d = Math.min(e.x, e.y) / 60, p = Math.floor(
+      H(0, (e.x - h) / d, l)
+    ), g = Math.floor(H(0, e.y / d, l));
+    let m = 2 + p + 1 + u, _ = 2 + g;
+    const f = new it(0);
+    let T = f;
+    const b = h / u;
+    let x = 0;
+    for (let y = 1; y < u + 1; y++)
+      T = T.createNext(x), x += b;
+    const P = (e.x - h) / (p + 1);
+    for (let y = u + 1; y < m; y++)
+      T = T.createNext(x), x += P;
+    const S = new it(0);
+    let k = S;
+    const O = e.y / (_ - 1);
+    let Z = 0;
+    for (let y = 0; y < _ - 1; y++)
+      Z += O, k = k.createNext(Z);
+    const z = [], N = [], D = i.clone();
+    if (r) {
+      let y = 0;
+      this.m_Book.hasCover && (y = Math.floor(this.m_Book.coverPaperCount / 2));
+      const B = Math.max(0.01, s);
+      D.left = 0, D.right = (this.getPX(y + 1, s) - this.getPX(y, s) + B) / e.x, D.down = B / e.y, D.up = B / e.y;
+    }
+    const C = new Me(a, D, !1);
+    C.insert(f, S, z, N), f.updateIndex(0), S.updateIndex(0), Zt(z, a.xSeams), Zt(N, a.zSeams);
+    const R = this.m_BindingVertexCount + 2, L = new Array(R);
+    a.xNoneSeamIndexes = L, T = f;
+    for (let y = 0; y < R; y++) {
+      L[y] = T.index;
+      do
+        T = T.next;
+      while (T.seam);
+    }
+    const v = f.getValues(), Q = S.getValues();
+    m = v.length, _ = Q.length;
+    const q = m * _, $ = [], j = new Array(q).fill(0), A = [], M = [], F = [], w = [];
+    ye(
+      $,
+      v,
+      Q,
+      e,
+      i,
+      this.m_Book.direction
+    );
+    const V = C.leftNode.index, E = C.downNode.index;
+    let G = C.rightNode.index, W = C.upNode.index;
+    G === 0 && (G = m - 1), W === 0 && (W = _ - 1);
+    for (let y = 0; y < _ - 1; y++)
+      for (let B = 0; B < m - 1; B++) {
+        if (r && y >= E && y < W && B >= V && B < G)
+          continue;
+        const J = y * m + B, tt = y * m + (B + 1), _t = (y + 1) * m + B, ht = (y + 1) * m + (B + 1);
+        j[J] += 2, j[tt] += 2, j[_t] += 2, j[ht] += 2, Pe(
+          A,
+          M,
+          J,
+          tt,
+          _t,
+          ht,
+          q
+        );
+      }
+    if (w.push(new St(0, 0, m - 1, _ - 1, !1, !1)), xe(w, F, $, m, _), a.baseXArray = v, a.baseZArray = Q, a.baseVertexCount = q, a.vertexCount = $.length, a.texcoords = $, a.weights = j, o) {
+      a.subMeshCount = 1;
+      const y = [];
+      y.push(...A), y.push(...F), y.push(...M), a.triangles = y;
+    } else
+      a.subMeshCount = 3, a.frontTriangles = A, a.backTriangles = M, a.borderTriangles = F;
+    return a.borders = w, a;
+  }
+  // ── updateRootPosition ────────────────────────────────────────────────
+  updateRootPosition() {
+    const t = this.m_Book.papers, e = t[0].transform.position.y, s = t[t.length - 1].transform.position.y;
+    let i = -Math.min(e, s);
+    i += t[0].thickness / 2, this.m_Root.position.set(0, i, this.m_Root.position.z);
+  }
+  // ── resetPaperPosition ────────────────────────────────────────────────
+  resetPaperPosition(t) {
+    const e = this.m_Book.papers, s = e.length;
+    let i = 0;
+    const r = e.length / 2 - 1, o = e.length / 2;
+    for (let x = 0; x < s; x++) {
+      const P = e[x];
+      P.updateTime();
+      const S = P.zTime, k = P.thickness;
+      i += S * k, x === r && (i += S * this.m_BindingMidSpace / 2), x === o && (i += S * this.m_BindingMidSpace / 2);
+    }
+    let a = this.getStackHeight(t.index) - t.thickness / 2;
+    const h = this.getStackZ(a), u = 180 + h;
+    let l = t.isFlipped ? 1 : 0, d = H(h, u, l);
+    const p = d * et, g = new c.Vector3(
+      Math.cos(p) * this.m_BindingRadius,
+      Math.sin(p) * this.m_BindingRadius,
+      0
+    );
+    g.z = t.margin;
+    let m = e[Math.floor(s / 2)].size.x, _ = this.m_BindingMidSpace, f = Math.sqrt(m * m - _ * _), T = Math.asin(f / m) * nt - 90;
+    if (t.index < Math.floor(s / 2)) {
+      let x = 0;
+      if (this.m_Book.alignToGround) {
+        m = e[0].size.x;
+        const P = this.m_StackHeight / 2;
+        _ = st(i, 0, P) - P, f = Math.sqrt(m * m - _ * _), x = (Math.asin(f / m) * nt - 90) * 2;
+      }
+      d = H(T, -x, l);
+    } else {
+      let x = 0;
+      if (this.m_Book.alignToGround) {
+        m = e[0].size.x;
+        const P = this.m_StackHeight / 2;
+        _ = P - st(i, P, P * 2), f = Math.sqrt(m * m - _ * _), x = (Math.asin(f / m) * nt - 90) * 2;
+      }
+      d = H(x, -T, l);
+    }
+    t.transform.position.copy(g), t.transform.quaternion.setFromEuler(
+      new c.Euler(0, 0, d * et)
+    );
+  }
+  // ── getPX  (private helper) ───────────────────────────────────────────
+  getPX(t, e) {
+    const s = this.m_Book.papers, i = s.length;
+    let r = 0;
+    const o = s.length / 2 - 1, a = s.length / 2;
+    for (let _ = 0; _ < i; _++)
+      r += 0 * e, _ === o && (r += 0 * this.m_BindingMidSpace / 2), _ === a && (r += 0 * this.m_BindingMidSpace / 2);
+    const h = this.getStackHeight(t) - e / 2, u = this.getStackZ(h), l = 180 + u, g = H(u, l, 0) * et;
+    return new c.Vector3(
+      Math.cos(g) * this.m_BindingRadius,
+      Math.sin(g) * this.m_BindingRadius,
+      0
+    ).x;
+  }
+  // ── updatePaperPosition ───────────────────────────────────────────────
+  updatePaperPosition(t) {
+    const e = this.m_Book.papers, s = e.length;
+    let i = 0;
+    const r = e.length / 2 - 1, o = e.length / 2;
+    for (let x = 0; x < s; x++) {
+      const P = e[x];
+      P.updateTime();
+      const S = P.zTime, k = P.thickness;
+      i += S * k, x === r && (i += S * this.m_BindingMidSpace / 2), x === o && (i += S * this.m_BindingMidSpace / 2);
+    }
+    const a = this.getStackHeight(t.index) - t.thickness / 2, h = this.getStackZ(a + i), u = 180 + this.getStackZ(a + i - this.m_StackHeight);
+    let l = t.zTime, d = H(h, u, l);
+    const p = d * et, g = new c.Vector3(
+      Math.cos(p) * this.m_BindingRadius,
+      Math.sin(p) * this.m_BindingRadius,
+      0
+    );
+    g.z = t.margin;
+    let m = e[Math.floor(s / 2)].size.x, _ = this.m_BindingMidSpace, f = Math.sqrt(m * m - _ * _), T = Math.asin(f / m) * nt - 90;
+    if (t.index < Math.floor(s / 2)) {
+      let x = 0;
+      if (this.m_Book.alignToGround) {
+        m = e[0].size.x;
+        const P = this.m_StackHeight / 2;
+        _ = st(i, 0, P) - P, f = Math.sqrt(m * m - _ * _), x = (Math.asin(f / m) * nt - 90) * 2;
+      }
+      d = H(T, -x, l);
+    } else {
+      let x = 0;
+      if (this.m_Book.alignToGround) {
+        m = e[0].size.x;
+        const P = this.m_StackHeight / 2;
+        _ = P - st(i, P, P * 2), f = Math.sqrt(m * m - _ * _), x = (Math.asin(f / m) * nt - 90) * 2;
+      }
+      d = H(x, -T, l);
+    }
+    t.transform.position.copy(g), t.transform.quaternion.setFromEuler(
+      new c.Euler(0, 0, d * et)
+    );
+  }
+  // ── getStackHeight ────────────────────────────────────────────────────
+  getStackHeight(t) {
+    const e = this.m_Book.papers;
+    let s = 0;
+    const i = e.length;
+    for (let r = t; r < i; r++)
+      s += e[r].thickness;
+    return t < Math.floor(i / 2) && (s += this.m_BindingMidSpace), s;
+  }
+  // ── getStackZ ─────────────────────────────────────────────────────────
+  getStackZ(t) {
+    t = st(t, 0, this.m_StackHeight);
+    const e = t - this.m_StackHeight * 0.5;
+    return Math.asin(e / this.m_BindingRadius) * nt;
+  }
+  // ── onLateUpdate ──────────────────────────────────────────────────────
+  onLateUpdate() {
+    const t = this.m_Book.papers;
+    for (const e of t)
+      this.updatePaperPosition(e);
+    this.m_Root.updateMatrixWorld(!0), this.updateBindingVertices();
+    for (const e of t)
+      e.updateMesh();
+    this.updateRootPosition();
+  }
+  // ── updateBindingVertices ─────────────────────────────────────────────
+  updateBindingVertices() {
+    const t = this.m_Book.papers;
+    let e = new c.Vector3(0, 0, 0), s = new c.Vector3(0, 0, 0), i = this.m_BindingRadius * 0.6;
+    const r = this.m_StapleThickness * 0.5, o = t[0].thickness, a = this.m_Root.matrixWorld.clone(), h = t.length;
+    for (let u = 0; u < h; u++) {
+      const l = t[u], d = l.transform, p = l.meshData.pattern, g = l.meshData.baseVertices, m = p.baseXArray, _ = p.baseZArray, f = m.length, T = _.length, b = this.m_BindingVertexCount + 1, x = l.thickness, P = p.xNoneSeamIndexes, S = d.position.clone();
+      let k = u, O = r;
+      u >= Math.floor(h / 2) && (k = h - u - 1, O *= -1);
+      const Z = (o + x) * 0.5 + x * (k - 1), z = d.matrixWorld.clone().invert().multiply(a), N = k / (h / 2);
+      i = this.m_BindingRadius * H(0.45, 0.65, 1 - N);
+      for (let D = 0; D < T; D++) {
+        const C = _[D], R = new c.Vector3(0, 0, S.z + C), L = S.clone();
+        L.z += C;
+        const v = l.getDirection(C).multiplyScalar(i).add(L.clone());
+        if (u === 0 && D === 0) {
+          const A = t[h - 1], F = A.transform.position.clone().clone();
+          F.z += C;
+          const w = A.getDirection(C).multiplyScalar(i).add(F);
+          s = v.clone().sub(w).normalize(), e = new c.Vector3(
+            -s.y,
+            s.x,
+            0
+          ).normalize().negate();
+          const V = Math.atan2(e.y, e.x) * nt;
+          this.stapleMesh.rotation.set(0, 0, V * et);
+        }
+        k > 0 && R.add(e.clone().multiplyScalar(Z));
+        const Q = D * f;
+        g[Q] = R.clone().applyMatrix4(z), R.add(s.clone().multiplyScalar(O));
+        const q = R.clone().applyMatrix4(z), $ = v.clone().applyMatrix4(z), j = L.clone().applyMatrix4(z);
+        g[Q + P[1]] = q;
+        for (let A = 2; A < b; A++) {
+          const M = Qt(1, b, A);
+          g[Q + P[A]] = Gt(
+            q,
+            $,
+            j,
+            M
+          );
+        }
+      }
+    }
+  }
+  // ── Getters for binding parameters (useful for external code) ─────────
+  get bindingRadius() {
+    return this.m_BindingRadius;
+  }
+  get bindingMidSpace() {
+    return this.m_BindingMidSpace;
+  }
+  get stackHeight() {
+    return this.m_StackHeight;
+  }
+  get bindingVertexCount() {
+    return this.m_BindingVertexCount;
+  }
+  get quality() {
+    return this.m_Quality;
+  }
+  get stapleMargin() {
+    return this.m_StapleMargin;
+  }
+  get stapleThickness() {
+    return this.m_StapleThickness;
+  }
+}
+class is {
+  constructor(t) {
+    this.mesh = t;
+  }
+  setVisibility(t) {
+    this.mesh.visible = t;
+  }
+  updateCollider() {
+  }
+  get castShadows() {
+    return this.mesh.castShadow;
+  }
+  set castShadows(t) {
+    this.mesh.castShadow = t;
+  }
+  get bounds() {
+    const t = new c.Box3();
+    return this.mesh.geometry && (this.mesh.geometry.computeBoundingBox(), this.mesh.geometry.boundingBox && (t.copy(this.mesh.geometry.boundingBox), t.applyMatrix4(this.mesh.matrixWorld))), t;
+  }
+  get transform() {
+    return this.mesh;
+  }
+  get meshObject() {
+    return this.mesh;
+  }
+}
+class Ps extends Ue {
+  constructor() {
+    super(...arguments), this.quality = 3, this.stapleSetup = new ts();
+  }
+  createBound(t, e, s, i) {
+    return new ss(
+      this.quality,
+      this.stapleSetup,
+      t,
+      e
+    );
+  }
+}
+export {
+  Ve as AnimationCurve,
+  dt as AutoTurnDirection,
+  be as AutoTurnMode,
+  at as AutoTurnSetting,
+  Re as AutoTurnSettingCurveTimeMode,
+  Ie as AutoTurnSettingMode,
+  ct as AutoTurnSettings,
+  cs as Book,
+  Ue as BookBinding,
+  Cs as BookBound,
+  xs as BookContent,
+  vt as BookContext,
+  X as BookDirection,
+  as as BookHeightException,
+  us as BookInteraction,
+  ke as BookRenderer,
+  pt as Cylinder,
+  we as MeshFactory,
+  Ms as PageContent,
+  fe as Paper,
+  St as PaperBorder,
+  Ht as PaperMaterialData,
+  Xt as PaperMeshData,
+  Be as PaperMeshDataPool,
+  it as PaperNode,
+  Me as PaperNodeMargin,
+  Xe as PaperPattern,
+  wt as PaperSeam,
+  lt as PaperSetup,
+  yt as PaperUVMargin,
+  Se as RendererFactory,
+  qt as SpritePageContent2,
+  Ps as StapleBookBinding,
+  ss as StapleBookBound,
+  ts as StapleSetup,
+  De as ThreeBook,
+  ps as createPageTexture,
+  Le as drawImageWithFit,
+  fs as loadImage,
+  ds as useAutoTurn,
+  Ct as useBook,
+  gs as useBookContent,
+  ms as useBookControls,
+  Ae as useBookRef,
+  _s as useBookState,
+  Fe as usePageTurning,
+  ls as useRequiredBook
+};