@objectifthunes/three-book 0.1.0

package/dist/index.js

@@ -0,0 +1,2692 @@
+import * as c from "three";
+class ut {
+  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, n = e * Math.PI / 180, o = Math.cos(i), a = Math.sin(i), h = t * o, m = t * a, l = 0, _ = Math.cos(n), p = Math.sin(n), d = h * _ + l * p, u = m, f = -h * p + l * _;
+    return new c.Vector3(d, u, f);
+  }
+  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, n = this.eulerRotateVector(this.m_Radius, this.m_EulerY, i);
+      t.copy(n.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 ut();
+    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(r, t, e, s, i = 1 / 0, n = 1 / 60) {
+  s = Math.max(s, 1e-4);
+  const o = 2 / s, a = o * n, h = 1 / (1 + a + 0.48 * a * a + 0.235 * a * a * a);
+  let m = r - t;
+  const l = t, _ = i * s;
+  m = c.MathUtils.clamp(m, -_, _), t = r - m;
+  const p = (e + o * m) * n;
+  e = (e - o * p) * h;
+  let d = t + (m + p) * h;
+  return l - r > 0 == d > l && (d = l, e = (d - l) / n), { value: d, velocity: e };
+}
+function te(r, t, e, s, i = 1 / 0, n = 1 / 60) {
+  const o = pt(
+    r.x,
+    t.x,
+    e.x,
+    s.x,
+    i,
+    n
+  ), a = pt(
+    r.y,
+    t.y,
+    e.y,
+    s.y,
+    i,
+    n
+  ), h = pt(
+    r.z,
+    t.z,
+    e.z,
+    s.z,
+    i,
+    n
+  );
+  return e.set(o.velocity, a.velocity, h.velocity), new c.Vector3(o.value, a.value, h.value);
+}
+function ee(r) {
+  return new c.Vector3(r.x, 0, r.y);
+}
+function se(r) {
+  return new c.Vector3(r.x, r.z, 0);
+}
+function St(r, t, e) {
+  const s = t * t - 4 * r * e;
+  if (s < 0)
+    return { rootCount: 0, root0: 0, root1: 0 };
+  if (s === 0)
+    return { rootCount: 1, root0: -t / 2 * r, root1: 0 };
+  {
+    const i = Math.sqrt(s);
+    return {
+      rootCount: 2,
+      root0: (-t + i) / (2 * r),
+      root1: (-t - i) / (2 * r)
+    };
+  }
+}
+function kt(r, t, e) {
+  return ie(r, t, e) ? r.clone() : ne(
+    new c.Vector2(r.x, t.y),
+    r,
+    t,
+    e
+  );
+}
+function ie(r, t, e) {
+  const s = r.x - t.x;
+  let i = r.y - t.y;
+  return i *= e.x / e.y, Math.sqrt(s * s + i * i) < e.x;
+}
+function ne(r, t, e, s) {
+  const i = e.x, n = e.y, o = r.x, a = r.y, h = t.x, m = t.y, l = s.x, _ = s.y, p = 1 / (l * l), d = 1 / (_ * _);
+  if (Math.abs(o - h) < 1e-5) {
+    if (o >= i - l && o <= i + l) {
+      const u = St(
+        d,
+        -2 * d * n,
+        p * (o * o - 2 * i * o + i * i) + d * n * n - 1
+      );
+      if (u.rootCount === 1)
+        return new c.Vector2(o, u.root0);
+      if (u.rootCount === 2) {
+        let f = u.root0, g = u.root1;
+        return a < m && ([f, g] = [g, f]), new c.Vector2(o, g);
+      }
+    }
+  } else {
+    const u = (m - a) / (h - o), f = a - u * o, g = f - n, w = St(
+      p + d * u * u,
+      2 * g * u * d - 2 * i * p,
+      i * i * p + g * g * d - 1
+    );
+    if (w.rootCount === 1)
+      return new c.Vector2(w.root0, u * w.root0 + f);
+    if (w.rootCount === 2) {
+      let B = w.root0, x = w.root1;
+      return o < h && ([B, x] = [x, B]), new c.Vector2(x, u * x + f);
+    }
+  }
+  return r.clone();
+}
+function vt(r, t) {
+  const e = r.origin.clone().applyMatrix4(t), s = r.origin.clone().add(r.direction).applyMatrix4(t);
+  return new c.Ray(e, s.sub(e));
+}
+function re(r) {
+  return new c.Vector4(-r.x, r.y, r.z + r.x, r.w);
+}
+function oe(r) {
+  return new c.Vector4(r.x, -r.y, r.z, r.w + r.y);
+}
+var E = /* @__PURE__ */ ((r) => (r[r.LeftToRight = 0] = "LeftToRight", r[r.RightToLeft = 1] = "RightToLeft", r[r.UpToDown = 2] = "UpToDown", r[r.DownToUp = 3] = "DownToUp", r))(E || {});
+const bt = Math.PI / 180, Bt = 180 / Math.PI, ae = 1192093e-13;
+function _t(r) {
+  return r < 0 ? 0 : r > 1 ? 1 : r;
+}
+function Rt(r, t, e) {
+  return r < t ? t : r > e ? e : r;
+}
+function mt(r, t, e) {
+  return r !== t ? _t((e - r) / (t - r)) : 0;
+}
+function Vt(r, t, e) {
+  return r + (t - r) * e;
+}
+function It(r, t, e) {
+  return r + (t - r) * e;
+}
+function zt(r, t, e) {
+  return e = _t((e - r) / (t - r)), e * e * (3 - 2 * e);
+}
+class he {
+  // ---- 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 ut(), 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 * bt, 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 - _t(t));
+    e <= 0.5 ? this.m_TurningRadius = mt(0, 0.5, e) * this.m_Size.x / Math.PI : this.m_TurningRadius = this.m_Size.x / (Math.max(180 * (1 - mt(0.5, 1, e)), 5) * bt), this.m_TurningRadius = Math.max(
+      this.m_TurningRadius,
+      this.m_MinTurningRadius
+    );
+  }
+  startTurning(t) {
+    var n, o;
+    const e = t.clone();
+    t = vt(
+      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 */
+        ), (n = this.m_Prev) == null || n.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 = Vt(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 n = _t(this.m_FallTime / this.m_FallDuration);
+      n = zt(0, 1, n), n = zt(0, 1, n), this.m_CurrentHandle.lerpVectors(
+        this.m_StartHandle,
+        this.m_EndHandle,
+        this.m_IsFallingLeft ? n : 1 - n
+      ), this.m_FallTime += t, e = Math.abs(n - 1) < ae;
+    } else {
+      const n = new c.Vector3(
+        this.m_FallTime,
+        0,
+        this.m_FallTime * 0.75
+      );
+      this.m_CurrentHandle = te(
+        this.m_CurrentHandle,
+        this.m_EndHandle,
+        this.m_HandleVelocity,
+        n,
+        1 / 0,
+        t
+      ), e = Math.abs(this.m_EndHandle.x - this.m_CurrentHandle.x) < 1e-4;
+    }
+    if (e) {
+      if (this.m_IsFallingLeft) {
+        const n = this.m_Transform.scale;
+        n.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(
+      mt(-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 === E.UpToDown || s === E.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 = vt(
+      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 n = i;
+      if (n.x > 0 && n.x < this.m_Size.x && n.z > 0 && n.z < this.m_Size.y || e)
+        return n;
+    }
+    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 = oe(s) : s = re(s);
+    const i = this.m_FrontContent.texture, n = 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(n, 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(n, 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 = Vt(
+        Math.min(t, e),
+        Math.max(t, e),
+        0.9
+      );
+      const s = this.m_MeshData.pattern.baseXArray, i = this.m_MeshData.pattern.baseZArray, n = 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])
+      ), m = o.clone().sub(n).normalize(), l = h.clone().sub(a).normalize(), _ = Bt * Math.atan2(m.y, m.x), p = Bt * Math.atan2(l.y, l.x), d = (_ + p) / 2;
+      this.m_ZTime = d / 180;
+    } else
+      this.m_XTime = 0, this.m_ZTime = 0;
+  }
+  findTime(t) {
+    return t = this.rollPoint(t), mt(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), n = s.distanceTo(this.m_StartHandle), o = Math.max(i - this.m_TurningRadius, 0.01), a = Math.max(n - this.m_TurningRadius, 0.01), h = this.m_StartHandle.z, m = new c.Vector2(
+      0,
+      h + (e.z - h) * (o / i)
+    ), l = new c.Vector2(
+      0,
+      h + (s.z - h) * (a / n)
+    ), _ = new c.Vector2(i, o), p = new c.Vector2(n, a);
+    t.x = Rt(t.x, -this.m_Size.x, this.m_Size.x);
+    const d = se(t), u = kt(
+      new c.Vector2(d.x, d.y),
+      m,
+      _
+    ), f = kt(
+      new c.Vector2(u.x, u.y),
+      l,
+      p
+    ), g = ee(
+      new c.Vector3(f.x, f.y, 0)
+    );
+    this.m_CurrentHandle.copy(g);
+  }
+  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
+      )
+    ), n = t.clone(), o = new ut();
+    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(n).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 ? n.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 m, 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 _ = this.m_Transform.scale;
+      _.x *= -1;
+    }
+    this.switchMeshData(
+      0
+      /* Highpoly */
+    ), (m = this.m_Prev) == null || m.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 n = this.m_Size.x, o = this.m_Size.y;
+    e = Rt(e, -0.99, 0.99);
+    const a = It(0.5, 1, e), h = It(0.5, 0, e);
+    this.m_StartHandle.set(n, 0, o * a), this.m_EndHandle.set(-n, 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 E.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 E.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 E.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 E.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 gt = Y;
+const L = class L {
+  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 gt(), this.margin = 0, this.bookDirection = E.LeftToRight, this.color = (t == null ? void 0 : t.color) ?? new c.Color(1, 1, 1), this.width = (t == null ? void 0 : t.width) ?? L.kMinSize * 2, this.height = (t == null ? void 0 : t.height) ?? L.kMinSize * 2, this.thickness = (t == null ? void 0 : t.thickness) ?? L.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, L.kMinSize);
+  }
+  get height() {
+    return this.bookDirection > 1 ? this.m_Width : this.m_Height;
+  }
+  set height(t) {
+    this.m_Height = Math.max(t, L.kMinSize);
+  }
+  get thickness() {
+    return this.m_Thickness;
+  }
+  set thickness(t) {
+    this.m_Thickness = Math.max(t, L.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(
+      L.kMinQuality,
+      Math.min(t, L.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);
+  }
+};
+L.kMinSize = 1, L.kMinThickness = 1e-4, L.kMinQuality = 1, L.kMaxQuality = 5;
+let ht = L;
+class Dt {
+  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 At(r, t, e, s = new c.Vector3()) {
+  let i = t.x - r.x, n = t.y - r.y, o = t.z - r.z, a = 1 / Math.sqrt(i * i + n * n + o * o);
+  i *= a, n *= a, o *= a;
+  let h = e.x - r.x, m = e.y - r.y, l = e.z - r.z;
+  a = 1 / Math.sqrt(h * h + m * m + l * l), h *= a, m *= a, l *= a;
+  const _ = n * l - o * m, p = o * h - i * l, d = i * m - n * h;
+  return a = 1 / Math.sqrt(_ * _ + p * p + d * d), s.set(_ * a, p * a, d * a);
+}
+class st {
+  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 st(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 st(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 Pt {
+  constructor(t, e, s, i) {
+    this.active = !0, this.prevIndex = t, this.index = e, this.nextIndex = s, this.time = i;
+  }
+  clone() {
+    const t = new Pt(this.prevIndex, this.index, this.nextIndex, this.time);
+    return t.active = this.active, t;
+  }
+}
+class wt {
+  constructor(t, e, s, i, n, o = !0) {
+    this.startX = t, this.startZ = e, this.endX = s, this.endZ = i, this.flip = n, this.left = o;
+  }
+  clone() {
+    return new wt(
+      this.startX,
+      this.startZ,
+      this.endX,
+      this.endZ,
+      this.flip,
+      this.left
+    );
+  }
+}
+class le {
+  constructor(t, e, s) {
+    const i = t.size;
+    this.leftNode = new st(e.left * i.x, s, !0), this.rightNode = new st((1 - e.right) * i.x, s, !0), this.downNode = new st(e.down * i.y, s, !0), this.upNode = new st((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 lt(r, t, e) {
+  if (r === t) return 0;
+  const s = (e - r) / (t - r);
+  return Math.max(0, Math.min(1, s));
+}
+function Mt(r, t) {
+  for (const e of r) {
+    const s = e.prevNoneSeam, i = e.nextNoneSeam, n = lt(s.value, i.value, e.value), o = new Pt(s.index, e.index, i.index, n);
+    t.push(o);
+  }
+}
+function xt(r, t, e, s, i) {
+  for (const n of r) {
+    if (!n.active) return;
+    for (let o = 0; o < s; o++) {
+      const a = n.prevIndex, h = n.nextIndex, m = t[o * e + a], l = t[o * e + h], _ = t[o * e + n.index];
+      i ? Gt(m, l, n.time, _) : _.copy(m).lerp(l, n.time);
+    }
+  }
+}
+function Ct(r, t, e, s, i) {
+  for (const n of r) {
+    if (!n.active) return;
+    for (let o = 0; o < e; o++) {
+      const a = n.prevIndex, h = n.nextIndex, m = t[a * e + o], l = t[h * e + o], _ = t[n.index * e + o];
+      i ? Gt(m, l, n.time, _) : _.copy(m).lerp(l, n.time);
+    }
+  }
+}
+function Gt(r, t, e, s = new c.Vector3()) {
+  const i = Math.sqrt(r.x * r.x + r.y * r.y + r.z * r.z), n = Math.sqrt(t.x * t.x + t.y * t.y + t.z * t.z);
+  if (i === 0 || n === 0)
+    return s.copy(r).lerp(t, e);
+  const o = r.x / i, a = r.y / i, h = r.z / i, m = t.x / n, l = t.y / n, _ = t.z / n;
+  let p = o * m + a * l + h * _;
+  p = Math.max(-1, Math.min(1, p));
+  const d = Math.acos(p);
+  if (d < 1e-6)
+    return s.copy(r).lerp(t, e);
+  const u = Math.sin(d), f = Math.sin((1 - e) * d) / u, g = Math.sin(e * d) / u, w = i + (n - i) * e;
+  return s.set(
+    (o * f + m * g) * w,
+    (a * f + l * g) * w,
+    (h * f + _ * g) * w
+  );
+}
+function qt(r, t, e, s, i) {
+  for (const n of r) {
+    const o = (n.endX - n.startX + 1) * 2, a = (n.endZ - n.startZ + 1) * 2, h = e.length;
+    for (let l = 0, _ = n.endX - n.startX; l < _; l++) {
+      const p = h + l * 2 + 0, d = h + l * 2 + 1, u = h + l * 2 + 2, f = h + l * 2 + 3;
+      n.flip ? Ft(t, p, d, u, f, o) : Ht(t, p, d, u, f, o);
+    }
+    if (n.left)
+      for (let l = 0, _ = n.endZ - n.startZ; l < _; l++) {
+        const p = h + l * 2 + 0 + o * 2, d = h + l * 2 + 1 + o * 2, u = h + l * 2 + 2 + o * 2, f = h + l * 2 + 3 + o * 2;
+        n.flip ? Ft(t, p, d, u, f, a) : Ht(t, p, d, u, f, a);
+      }
+    else
+      for (let l = 0, _ = n.endZ - n.startZ; l < _; l++) {
+        const p = h + l * 2 + 0 + o * 2 + a, d = h + l * 2 + 1 + o * 2 + a, u = h + l * 2 + 2 + o * 2 + a, f = h + l * 2 + 3 + o * 2 + a;
+        n.flip ? ft(t, p, d, u, f) : dt(t, p, d, u, f);
+      }
+    const m = s * i;
+    for (let l = n.startX; l <= n.endX; l++) {
+      const _ = n.startZ * s + l;
+      e.push(e[_].clone()), e.push(e[_ + m].clone());
+    }
+    for (let l = n.startX; l <= n.endX; l++) {
+      const _ = l + n.endZ * s;
+      e.push(e[_ + m].clone()), e.push(e[_].clone());
+    }
+    for (let l = n.startZ; l <= n.endZ; l++) {
+      const _ = n.startX + l * s;
+      e.push(e[_ + m].clone()), e.push(e[_].clone());
+    }
+    for (let l = n.startZ; l <= n.endZ; l++) {
+      const _ = l * s + n.endX;
+      e.push(e[_].clone()), e.push(e[_ + m].clone());
+    }
+  }
+}
+function Wt(r, t, e, s, i) {
+  const n = s * i;
+  let o = n * 2;
+  const a = new c.Vector3();
+  for (const h of r) {
+    for (let m = h.startX; m <= h.endX; m++) {
+      const l = m + h.startZ * s, _ = t[l], p = t[l + s];
+      a.subVectors(_, p).normalize(), h.flip && a.multiplyScalar(-1), e[o].copy(a), t[o++].copy(_), e[o].copy(a), t[o++].copy(t[l + n]);
+    }
+    for (let m = h.startX; m <= h.endX; m++) {
+      const l = m + h.endZ * s, _ = t[l + n], p = t[l + n - s];
+      a.subVectors(_, p).normalize(), h.flip && a.multiplyScalar(-1), e[o].copy(a), t[o++].copy(_), e[o].copy(a), t[o++].copy(t[l]);
+    }
+    for (let m = h.startZ; m <= h.endZ; m++) {
+      const l = m * s + h.startX, _ = t[l + n], p = t[l + n + 1];
+      a.subVectors(_, p).normalize(), h.flip && a.multiplyScalar(-1), e[o].copy(a), t[o++].copy(_), e[o].copy(a), t[o++].copy(t[l]);
+    }
+    for (let m = h.startZ; m <= h.endZ; m++) {
+      const l = m * s + h.endX, _ = t[l], p = t[l - 1];
+      a.subVectors(_, p).normalize(), h.flip && a.multiplyScalar(-1), e[o].copy(a), t[o++].copy(_), e[o].copy(a), t[o++].copy(t[l + n]);
+    }
+  }
+}
+function ce(r, t, e, s, i) {
+  const n = [];
+  for (const o of r) {
+    for (let a = o.startX; a < o.endX; a++) {
+      const h = a + o.startZ * e, m = t[h].clone().applyMatrix4(i), l = t[h + 1].clone().applyMatrix4(i);
+      n.push([m, l]);
+    }
+    for (let a = o.startX; a < o.endX; a++) {
+      const h = a + o.endZ * e, m = t[h].clone().applyMatrix4(i), l = t[h + 1].clone().applyMatrix4(i);
+      n.push([m, l]);
+    }
+    for (let a = o.startZ; a < o.endZ; a++) {
+      const h = a * e + o.startX, m = (a + 1) * e + o.startX, l = t[h].clone().applyMatrix4(i), _ = t[m].clone().applyMatrix4(i);
+      n.push([l, _]);
+    }
+    for (let a = o.startZ; a < o.endZ; a++) {
+      const h = a * e + o.endX, m = (a + 1) * e + o.endX, l = t[h].clone().applyMatrix4(i), _ = t[m].clone().applyMatrix4(i);
+      n.push([l, _]);
+    }
+  }
+  return n;
+}
+function Ht(r, t, e, s, i, n) {
+  dt(r, t, e, s, i), t += n, e += n, s += n, i += n, dt(r, t, e, s, i);
+}
+function Ft(r, t, e, s, i, n) {
+  ft(r, t, e, s, i), t += n, e += n, s += n, i += n, ft(r, t, e, s, i);
+}
+function Qt(r, t, e, s, i, n, o) {
+  dt(r, e, s, i, n), e += o, s += o, i += o, n += o, ft(t, e, s, i, n);
+}
+function $t(r, t, e, s, i, n) {
+  const o = i.left * s.x, a = (1 - i.right) * s.x, h = i.down * s.y, m = (1 - i.up) * s.y, l = t.length, _ = e.length;
+  if (n > 1)
+    for (let d = 0; d < _; d++)
+      for (let u = 0; u < l; u++) {
+        const f = lt(a, o, t[u]), g = lt(m, h, e[d]);
+        r.push(new c.Vector2(g, f));
+      }
+  else
+    for (let d = 0; d < _; d++)
+      for (let u = 0; u < l; u++) {
+        const f = lt(o, a, t[u]), g = lt(m, h, e[d]);
+        r.push(new c.Vector2(f, g));
+      }
+  const p = r.length;
+  for (let d = 0; d < p; d++)
+    r.push(r[d].clone());
+}
+function dt(r, t, e, s, i) {
+  r.push(t), r.push(s), r.push(e), r.push(e), r.push(s), r.push(i);
+}
+function ft(r, t, e, s, i) {
+  r.push(t), r.push(e), r.push(s), r.push(e), r.push(i), r.push(s);
+}
+function Yt(r, t, e, s) {
+  const i = [];
+  for (let n = 0; n < e - 1; n++)
+    for (let o = 0; o < t - 1; o++) {
+      let a = r[n * t + o].clone(), h = r[n * t + o + 1].clone(), m = r[(n + 1) * t + o].clone(), l = r[(n + 1) * t + o + 1].clone();
+      a.applyMatrix4(s), h.applyMatrix4(s), m.applyMatrix4(s), l.applyMatrix4(s), i.push([a, h, m, l]);
+    }
+  return i;
+}
+const Fe = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  addBorders: qt,
+  addFrontAndBackFaces: Qt,
+  addFrontAndBackTexcoords: $t,
+  debugDrawBorders: ce,
+  drawWireframe: Yt,
+  seamNodesToSeams: Mt,
+  updateBorders: Wt,
+  updateXSeams: xt,
+  updateZSeams: Ct
+}, Symbol.toStringTag, { value: "Module" }));
+class Zt {
+  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), n = new Float32Array(e.vertexCount * 2);
+    for (let o = 0; o < e.texcoords.length; o++)
+      n[o * 2] = e.texcoords[o].x, n[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(n, 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, n = e.length, o = s.length;
+    let a = 0;
+    for (let h = 0; h < o; h++)
+      for (let m = 0; m < n; m++)
+        t[a++].set(e[m] + 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, n = this.m_Pattern.baseXArray.length, o = this.m_Pattern.baseZArray.length, a = this.m_Pattern.baseVertexCount, h = new c.Vector3(), m = new c.Vector3(), l = new c.Vector3();
+    for (let u = 0; u < a; u++)
+      s[u].set(0, 0, 0);
+    xt(this.m_Pattern.xSeams, t, n, o, !1), Ct(this.m_Pattern.zSeams, t, n, o, !1);
+    for (let u = 0; u < o - 1; u++) {
+      const f = u + 1;
+      for (let g = 0; g < n - 1; g++) {
+        const w = g + 1, B = u * n + g, x = u * n + w, y = f * n + g, S = f * n + w, v = t[B], Z = t[x], O = t[y], z = t[S];
+        At(v, O, Z, h), At(z, Z, O, m), l.addVectors(h, m), s[B].add(l), s[x].add(l), s[y].add(l), s[S].add(l);
+      }
+    }
+    for (let u = 0; u < a; u++)
+      s[u].divideScalar(i[u]).normalize();
+    xt(this.m_Pattern.xSeams, s, n, o, !0), Ct(this.m_Pattern.zSeams, s, n, o, !0);
+    const _ = this.m_Pattern.thickness / 2;
+    for (let u = 0; u < a; u++) {
+      const f = s[u];
+      s[u + a].copy(f).negate();
+      const g = t[u];
+      e[u].copy(g).addScaledVector(f, _), e[u + a].copy(g).addScaledVector(f, -_);
+    }
+    Wt(this.m_Pattern.borders, e, s, n, o);
+    const p = this.m_Geometry.getAttribute(
+      "position"
+    ), d = this.m_Geometry.getAttribute(
+      "normal"
+    );
+    for (let u = 0; u < e.length; u++) {
+      const f = e[u];
+      p.setXYZ(u, f.x, f.y, f.z);
+      const g = s[u];
+      d.setXYZ(u, g.x, g.y, g.z);
+    }
+    p.needsUpdate = !0, d.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 Yt(this.m_Vertices, e, s, t);
+  }
+}
+class me {
+  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 ue {
+  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 de(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 _e = 1;
+class de {
+  constructor(t, e, s) {
+    this.m_Visibility = !0, this.m_PropertyBlocks = /* @__PURE__ */ new Map(), this.m_MaterialTextures = /* @__PURE__ */ new Map(), this.m_Id = _e++, 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 n = this.getSTKey(i), o = this.m_MaterialTextures.get(e);
+    if (o && o.source === s && o.stKey === n) {
+      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: n
+    });
+  }
+  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 fe {
+  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 Zt(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 Zt(this.m_MeshFactory.get(), this.m_Pattern);
+  }
+  free(t) {
+    if (this.m_UseSharedData) throw new Error("Not implemented");
+    this.m_Stack.push(t);
+  }
+}
+var yt = /* @__PURE__ */ ((r) => (r[r.Next = 0] = "Next", r[r.Back = 1] = "Back", r))(yt || {}), pe = /* @__PURE__ */ ((r) => (r[r.Surface = 0] = "Surface", r[r.Edge = 1] = "Edge", r))(pe || {}), ge = /* @__PURE__ */ ((r) => (r[r.Constant = 0] = "Constant", r[r.RandomBetweenTwoConstants = 1] = "RandomBetweenTwoConstants", r[r.Curve = 2] = "Curve", r[r.RandomBetweenTwoCurves = 3] = "RandomBetweenTwoCurves", r))(ge || {}), Me = /* @__PURE__ */ ((r) => (r[r.PaperIndexTime = 0] = "PaperIndexTime", r[r.TurnIndexTime = 1] = "TurnIndexTime", r))(Me || {});
+class xe {
+  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 n = (t - e[i].time) / (e[i + 1].time - e[i].time);
+        return e[i].value + (e[i + 1].value - e[i].value) * n;
+      }
+    return e[s - 1].value;
+  }
+}
+function nt(r, t, e) {
+  return Math.max(t, Math.min(e, r));
+}
+function Ce(r, t, e) {
+  return r === t ? 0 : nt((e - r) / (t - r), 0, 1);
+}
+function Ot(r, t) {
+  return r + Math.random() * (t - r);
+}
+class rt {
+  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 rt();
+    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 rt();
+    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 Ot(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 Ot(
+        this.m_CurveMin.evaluate(s),
+        this.m_CurveMax.evaluate(s)
+      );
+    throw new Error("AutoTurnSettingMode not implemented");
+  }
+  /** @internal */
+  clampValues(t, e) {
+    return this.m_Constant = nt(this.m_Constant, t, e), this.m_ConstantMin = nt(this.m_ConstantMin, t, e), this.m_ConstantMax = nt(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 })), n = i.length;
+    let o = 1 / 0, a = -1 / 0;
+    for (let h = 0; h < n; h++) {
+      const m = i[h].time;
+      o = Math.min(o, m), a = Math.max(a, m);
+    }
+    for (let h = 0; h < n; h++) {
+      let m = i[h].time, l = i[h].value;
+      m = Ce(o, a, m), l = nt(l, e, s), i[h].time = m, i[h].value = l;
+    }
+    return new xe(i);
+  }
+  // ── Value-type clone ────────────────────────────────────────────────────
+  clone() {
+    const t = new rt();
+    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 R = class R {
+  constructor() {
+    this.m_Mode = 0, this.m_Twist = new rt(), this.m_Bend = new rt(1), this.m_Duration = new rt(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(
+      R.kMinTwist,
+      R.kMaxTwist
+    );
+  }
+  get bend() {
+    return this.m_Bend;
+  }
+  set bend(t) {
+    this.m_Bend = t.clampValues(
+      R.kMinBend,
+      R.kMaxBend
+    );
+  }
+  get duration() {
+    return this.m_Duration;
+  }
+  set duration(t) {
+    this.m_Duration = t.clampValues(
+      R.kMinDuration,
+      R.kMaxDuration
+    );
+  }
+  // ── Internal API ────────────────────────────────────────────────────────
+  /** @internal */
+  getModeValue() {
+    return this.m_Mode;
+  }
+  /** @internal */
+  getBendValue(t, e) {
+    return nt(
+      this.m_Bend.getValue(t, e),
+      R.kMinBend,
+      R.kMaxBend
+    );
+  }
+  /** @internal */
+  getDurationValue(t, e) {
+    return nt(
+      this.m_Duration.getValue(t, e),
+      R.kMinDuration,
+      R.kMaxDuration
+    );
+  }
+  /** @internal */
+  getTwistValue(t, e) {
+    return nt(
+      this.m_Twist.getValue(t, e),
+      R.kMinTwist,
+      R.kMaxTwist
+    );
+  }
+};
+R.kMinTwist = -1, R.kMaxTwist = 1, R.kMinBend = 0, R.kMaxBend = 1, R.kMinDuration = 0, R.kMaxDuration = 5;
+let Nt = R, Ze = 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."
+    );
+  }
+};
+const ot = class ot 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 ht({
+      color: new c.Color(1, 0, 0),
+      width: 2.1,
+      height: 3.1,
+      thickness: 0.04,
+      stiffness: 0.5
+    }), this.m_PagePaperSetup = new ht({
+      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 = E.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 ht({
+      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 ht({
+      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
+    }))), ot.s_Instances.add(this);
+  }
+  static get instances() {
+    return [...ot.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 === E.RightToLeft, s = this.m_Papers.length, i = (n, o) => {
+      let a = n * 2;
+      o && a++, e && (a = s * 2 - a - 1), t.includes(a) || t.push(a);
+    };
+    for (let n = 0; n < s; n++) {
+      const o = this.m_Papers[n];
+      if (o.isFalling || o.isTurning)
+        n > 0 && i(n - 1, !0), i(n, !1), i(n, !0), n < s - 1 && i(n + 1, !1);
+      else if (o.isOnRightStack) {
+        n > 0 && i(n - 1, !0), i(n, !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 n = i >= s;
+      this.m_Papers[i].restState(n);
+    }
+    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 n = typeof i == "number" ? new rt(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), m = o > 0 ? n.getValue(h, a) : 0, l = e.getModeValue(), _ = e.getTwistValue(h, a), p = e.getBendValue(h, a), d = e.getDurationValue(h, a);
+      this.m_AutoTurnQueue.push({ direction: t, mode: l, twist: _, bend: p, duration: d, delay: m });
+    }
+    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 === yt.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 === yt.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() {
+    ot.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() {
+    ot.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 me()), this.m_RendererFactory === null) {
+      const C = new c.Object3D();
+      C.name = "Root", this.add(C), this.m_Root = C, this.m_RendererFactory = new ue(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 Dt(this.m_CoverPaperSetup), s = new Dt(this.m_PagePaperSetup);
+    this.m_Content.init(this);
+    let i = this.m_Content.coverContents, n = this.m_Content.pageContents, o = this.m_InitialOpenProgress;
+    this.m_Content.direction % 2 !== 0 && (i = [...i].reverse(), n = [...n].reverse(), o = 1 - o), this.m_HasCover = i.length > 0, this.m_CoverPaperCount = Math.floor(i.length / 2), this.m_PagePaperCount = Math.floor(n.length / 2);
+    const a = this.m_CoverPaperCount + this.m_PagePaperCount, h = Math.floor(i.length / 4);
+    let m = 0, l = 0, _ = 0;
+    this.m_Papers = new Array(a);
+    for (let C = 0; C < a; C++) {
+      const V = this.m_HasCover && (C < h || C >= a - h), U = this.m_RendererFactory.get("Paper"), k = this.m_Papers[C] = new he(V, C, this, U);
+      k.renderer.castShadows = this.m_CastShadows, C < Math.round(c.MathUtils.lerp(0, a, o)) && (k.transform.scale.set(-1, 1, 1), k.setTime(1)), V ? (k.setContentData(i[l++], i[l++], C > h), k.setMaterialData(e), k.setPaperSetup(this.m_CoverPaperSetup)) : (k.setContentData(n[m++], n[m++]), k.setMaterialData(s), k.setPaperSetup(this.m_PagePaperSetup)), _ += k.thickness;
+    }
+    this.m_TotalThickness = _;
+    const p = this.m_Papers[0].thickness, d = this.m_Papers[Math.floor(a / 2)].thickness;
+    this.m_MinPaperThickness = Math.min(p, d), this.m_MaxPaperThickness = Math.max(p, d);
+    const u = this.m_Papers[0].size.x, f = this.m_Papers[Math.floor(a / 2)].size.x;
+    this.m_MinPaperWidth = Math.min(u, f);
+    const g = this.m_Papers[0].size.y, w = this.m_Papers[Math.floor(a / 2)].size.y;
+    this.m_MinPaperHeight = Math.min(g, w), 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 && n.length > 0, x = this.m_ReduceSubMeshes, y = this.createPaperMeshDataPool(this.m_PagePaperSetup, !0, x), S = B ? this.createPaperMeshDataPool(this.m_PagePaperSetup, !0, x, !0) : null, v = this.createPaperMeshDataPool(this.m_PagePaperSetup, !1), Z = this.createPaperMeshDataPool(this.m_CoverPaperSetup, !0), O = 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 V = this.m_Papers[C];
+      C !== 0 && (V.prev = this.m_Papers[C - 1]), C !== a - 1 && (V.next = this.m_Papers[C + 1]), V.noHole = D && (C === z || C === N), V.isCover ? V.setMeshData(Z.get(), null, O) : V.setMeshData(
+        y.get(),
+        (S == null ? void 0 : S.get()) ?? null,
+        v
+      );
+    }
+    this.m_IsBuilt = !0, this.m_RendererIds = this.m_RendererFactory.ids, this.update(0), this.m_Bound.binderRenderer.updateCollider(), this.m_CoverPaperSetup.bookDirection = E.LeftToRight, this.m_PagePaperSetup.bookDirection = E.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 n = e ? 0 : t.quality, o = this.m_Bound.createPaperPattern(
+      n,
+      t.size,
+      t.thickness,
+      t.uvMargin,
+      i,
+      s
+    );
+    return new fe(
+      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));
+  }
+};
+ot.s_Instances = /* @__PURE__ */ new Set();
+let Ut = ot;
+class ye {
+  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;
+  }
+}
+class Ne {
+  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 Lt {
+  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 Ue {
+  constructor() {
+    this.m_Direction = E.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 n = new Array(i);
+    for (let o = 0; o < i; o++)
+      n[o] = this.getContent(o < s ? t[o] : null);
+    return n;
+  }
+  nextMultipleOf4(t) {
+    return Math.ceil(t / 4) * 4;
+  }
+  getContent(t) {
+    if (t !== null) {
+      if (t instanceof c.Texture)
+        return new Lt(t);
+      if (typeof t.init == "function")
+        return t;
+    }
+    return new Lt(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, n = e + s * 2 - 1;
+    return t < i || t > n;
+  }
+  isPagePaperSideIndex(t) {
+    return !this.isCoverPaperSideIndex(t);
+  }
+}
+class Pe {
+}
+class Le {
+  constructor(t, e) {
+    this.m_Book = t, this.m_Root = e;
+  }
+}
+function Xt(r, t, e, s) {
+  const i = 1 - s;
+  return new c.Vector3(
+    i * i * r.x + 2 * i * s * t.x + s * s * e.x,
+    i * i * r.y + 2 * i * s * t.y + s * s * e.y,
+    i * i * r.z + 2 * i * s * t.z + s * s * e.z
+  );
+}
+function Et(r, t) {
+  return r++, r === t ? 0 : r;
+}
+function we(r, t) {
+  return r === 0 ? t - 1 : r - 1;
+}
+const Te = 0.01, Se = 0.1, ke = 0.04, ve = 0.4, be = 2, Be = 10, Re = 0, Ve = 5;
+function et(r, t, e) {
+  return Math.max(t, Math.min(e, r));
+}
+function Kt(r) {
+  return Math.max(0, Math.min(1, r));
+}
+function F(r, t, e) {
+  return r + (t - r) * e;
+}
+function jt(r, t, e) {
+  return r === t ? 0 : Kt((e - r) / (t - r));
+}
+function Ie(r, t) {
+  const e = r.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(), n = new c.Matrix4().makeBasis(s, i, e);
+  return new c.Quaternion().setFromRotationMatrix(n);
+}
+const tt = Math.PI / 180, it = 180 / Math.PI;
+class ze {
+  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 = et(t, Te, Se);
+  }
+  get margin() {
+    return this._margin;
+  }
+  set margin(t) {
+    this._margin = Kt(t);
+  }
+  get crown() {
+    return this._crown;
+  }
+  set crown(t) {
+    this._crown = et(t, ke, ve);
+  }
+  get count() {
+    return this._count;
+  }
+  set count(t) {
+    this._count = et(t, be, Be);
+  }
+  get quality() {
+    return this._quality;
+  }
+  set quality(t) {
+    this._quality = et(t, Re, Ve);
+  }
+}
+class De extends Error {
+  constructor() {
+    super("Book height is too large relative to paper width."), this.name = "BookHeightException";
+  }
+}
+class Ae {
+  // ── Constructor ────────────────────────────────────────────────────────
+  constructor(t, e, s, i, n) {
+    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 De();
+    const o = this.m_Book.coverPaperSetup, a = this.m_Book.pagePaperSetup, h = new c.BufferGeometry();
+    this.updateStapleMesh(e, h);
+    const m = n ?? new c.MeshStandardMaterial({
+      color: e.color,
+      metalness: 0.9,
+      roughness: 0.3
+    });
+    this.stapleMesh = new c.Mesh(h, m), 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 _ of this.m_Book.papers) {
+      const p = _.size.clone();
+      p.x -= this.m_BindingRadius, _.sizeXOffset = this.m_BindingRadius, _.size = p, _.setMinTurningRadius(l), _.updateTurningRadius(), this.updatePaperPosition(_);
+    }
+    this.updateRootPosition();
+  }
+  get binderRenderer() {
+    return this._binderRendererAdapter || (this._binderRendererAdapter = new He(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 * tt), 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, n = Math.max(
+      this.m_Book.minPaperHeight / 2 - s - i,
+      i
+    );
+    this.m_StapleMargin = F(i, n, 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 m = t.quality / 5, l = Math.floor(F(4, 20, m)), _ = Math.floor(F(4, 10, m)), p = Math.floor(F(3, 10, m)), d = this.m_StapleThickness / 2, u = d * 2.5, f = 0.9, g = d * 1;
+    let w = s / 2 * f;
+    w = Math.max(w, g * 2);
+    let B = 0;
+    B += this.m_Book.totalThickness / 2, B += d;
+    const x = -(this.m_Book.papers[0].thickness / 2 + d), y = [];
+    {
+      for (let I = 0; I < _; I++) {
+        const X = I / (_ - 1), W = F(-90, -180, X) * tt, P = new c.Vector3(
+          g * Math.sin(W),
+          0,
+          g * Math.cos(W)
+        );
+        P.x += g, P.z += g, P.x += x, y.push(P);
+      }
+      const M = new c.Vector3(B, 0, 0), H = new c.Vector3(B + u * 0.75, 0, 0), T = new c.Vector3(B - d * 0.5, 0, w);
+      for (let I = 0; I < p; I++) {
+        const X = I / (p - 1), q = Xt(M, H, T, X);
+        q.x += x, y.push(q);
+      }
+      y.reverse();
+    }
+    const S = new Array(l);
+    for (let M = 0; M < l; M++) {
+      const T = (90 - M * (360 / l)) * tt;
+      S[M] = new c.Vector3(Math.cos(T), Math.sin(T), 0), S[M].x *= 0.75;
+    }
+    const v = y.length, Z = v * l, O = new Array(Z * 2), z = new Array(Z * 2), N = new Array(
+      (Z * 2 - 1) * l * 2 * 3
+    );
+    for (let M = 0; M < Z * 2; M++)
+      O[M] = new c.Vector3(), z[M] = new c.Vector3();
+    let D = 0;
+    for (let M = 0; M < v; M++) {
+      const H = y[we(M, v)], T = y[M], I = y[Et(M, v)];
+      let X;
+      if (M === 0)
+        X = new c.Vector3(1, 0, -2).normalize();
+      else if (M === v - 1)
+        X = new c.Vector3(0, 0, 1);
+      else {
+        const K = T.clone().sub(H).normalize(), J = I.clone().sub(T).normalize();
+        X = K.add(J).multiplyScalar(0.5);
+      }
+      const q = new c.Vector3(0, 1, 0), W = Ie(X, q), P = D;
+      let b = jt(0, p / 4, M);
+      b = F(0.1, 1, b), b = Math.sqrt(b);
+      for (let K = 0; K < l; K++) {
+        const J = S[K].clone().applyQuaternion(W).multiplyScalar(b), ct = T.clone().add(J.clone().multiplyScalar(d));
+        O[D] = ct, z[D] = J.clone();
+        const at = T.clone().add(J.clone().multiplyScalar(d));
+        at.z = s - at.z;
+        const Jt = P + l - K - 1, Tt = Z * 2 - Jt - 1;
+        O[Tt] = at, z[Tt] = J.clone(), D++;
+      }
+    }
+    let C = 0;
+    const V = y.length * 2;
+    for (let M = 0; M < V - 1; M++) {
+      const H = M * l, T = (M + 1) * l;
+      for (let I = 0; I < l; I++) {
+        const X = Et(I, l), q = H + I, W = H + X, P = T + X, b = T + I;
+        N[C++] = q, N[C++] = b, N[C++] = W, N[C++] = W, N[C++] = b, N[C++] = P;
+      }
+    }
+    const U = [...O], k = [...z], Q = [...N], G = O.map((M) => M.clone()), $ = [...N];
+    for (let M = 0; M < a - 1; M++) {
+      const H = G.length;
+      for (let T = 0; T < $.length; T++)
+        $[T] += H;
+      for (let T = 0; T < G.length; T++)
+        G[T].z += h + s;
+      U.push(...G.map((T) => T.clone())), k.push(...z.map((T) => T.clone())), Q.push(...$);
+    }
+    const j = new Float32Array(U.length * 3), A = new Float32Array(k.length * 3);
+    for (let M = 0; M < U.length; M++)
+      j[M * 3] = U[M].x, j[M * 3 + 1] = U[M].y, j[M * 3 + 2] = U[M].z, A[M * 3] = k[M].x, A[M * 3 + 1] = k[M].y, A[M * 3 + 2] = k[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, n, o) {
+    const a = new ye();
+    a.size = e, a.thickness = s;
+    const h = this.m_BindingRadius;
+    a.baseXOffset = -h;
+    const m = this.m_Quality + 1;
+    this.m_BindingVertexCount = m;
+    const l = t / 5, _ = Math.min(e.x, e.y) / 60, p = Math.floor(
+      F(0, (e.x - h) / _, l)
+    ), d = Math.floor(F(0, e.y / _, l));
+    let u = 2 + p + 1 + m, f = 2 + d;
+    const g = new st(0);
+    let w = g;
+    const B = h / m;
+    let x = 0;
+    for (let P = 1; P < m + 1; P++)
+      w = w.createNext(x), x += B;
+    const y = (e.x - h) / (p + 1);
+    for (let P = m + 1; P < u; P++)
+      w = w.createNext(x), x += y;
+    const S = new st(0);
+    let v = S;
+    const Z = e.y / (f - 1);
+    let O = 0;
+    for (let P = 0; P < f - 1; P++)
+      O += Z, v = v.createNext(O);
+    const z = [], N = [], D = i.clone();
+    if (n) {
+      let P = 0;
+      this.m_Book.hasCover && (P = Math.floor(this.m_Book.coverPaperCount / 2));
+      const b = Math.max(0.01, s);
+      D.left = 0, D.right = (this.getPX(P + 1, s) - this.getPX(P, s) + b) / e.x, D.down = b / e.y, D.up = b / e.y;
+    }
+    const C = new le(a, D, !1);
+    C.insert(g, S, z, N), g.updateIndex(0), S.updateIndex(0), Mt(z, a.xSeams), Mt(N, a.zSeams);
+    const V = this.m_BindingVertexCount + 2, U = new Array(V);
+    a.xNoneSeamIndexes = U, w = g;
+    for (let P = 0; P < V; P++) {
+      U[P] = w.index;
+      do
+        w = w.next;
+      while (w.seam);
+    }
+    const k = g.getValues(), Q = S.getValues();
+    u = k.length, f = Q.length;
+    const G = u * f, $ = [], j = new Array(G).fill(0), A = [], M = [], H = [], T = [];
+    $t(
+      $,
+      k,
+      Q,
+      e,
+      i,
+      this.m_Book.direction
+    );
+    const I = C.leftNode.index, X = C.downNode.index;
+    let q = C.rightNode.index, W = C.upNode.index;
+    q === 0 && (q = u - 1), W === 0 && (W = f - 1);
+    for (let P = 0; P < f - 1; P++)
+      for (let b = 0; b < u - 1; b++) {
+        if (n && P >= X && P < W && b >= I && b < q)
+          continue;
+        const K = P * u + b, J = P * u + (b + 1), ct = (P + 1) * u + b, at = (P + 1) * u + (b + 1);
+        j[K] += 2, j[J] += 2, j[ct] += 2, j[at] += 2, Qt(
+          A,
+          M,
+          K,
+          J,
+          ct,
+          at,
+          G
+        );
+      }
+    if (T.push(new wt(0, 0, u - 1, f - 1, !1, !1)), qt(T, H, $, u, f), a.baseXArray = k, a.baseZArray = Q, a.baseVertexCount = G, a.vertexCount = $.length, a.texcoords = $, a.weights = j, o) {
+      a.subMeshCount = 1;
+      const P = [];
+      P.push(...A), P.push(...H), P.push(...M), a.triangles = P;
+    } else
+      a.subMeshCount = 3, a.frontTriangles = A, a.backTriangles = M, a.borderTriangles = H;
+    return a.borders = T, 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 n = e.length / 2 - 1, o = e.length / 2;
+    for (let x = 0; x < s; x++) {
+      const y = e[x];
+      y.updateTime();
+      const S = y.zTime, v = y.thickness;
+      i += S * v, x === n && (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), m = 180 + h;
+    let l = t.isFlipped ? 1 : 0, _ = F(h, m, l);
+    const p = _ * tt, d = new c.Vector3(
+      Math.cos(p) * this.m_BindingRadius,
+      Math.sin(p) * this.m_BindingRadius,
+      0
+    );
+    d.z = t.margin;
+    let u = e[Math.floor(s / 2)].size.x, f = this.m_BindingMidSpace, g = Math.sqrt(u * u - f * f), w = Math.asin(g / u) * it - 90;
+    if (t.index < Math.floor(s / 2)) {
+      let x = 0;
+      if (this.m_Book.alignToGround) {
+        u = e[0].size.x;
+        const y = this.m_StackHeight / 2;
+        f = et(i, 0, y) - y, g = Math.sqrt(u * u - f * f), x = (Math.asin(g / u) * it - 90) * 2;
+      }
+      _ = F(w, -x, l);
+    } else {
+      let x = 0;
+      if (this.m_Book.alignToGround) {
+        u = e[0].size.x;
+        const y = this.m_StackHeight / 2;
+        f = y - et(i, y, y * 2), g = Math.sqrt(u * u - f * f), x = (Math.asin(g / u) * it - 90) * 2;
+      }
+      _ = F(x, -w, l);
+    }
+    t.transform.position.copy(d), t.transform.quaternion.setFromEuler(
+      new c.Euler(0, 0, _ * tt)
+    );
+  }
+  // ── getPX  (private helper) ───────────────────────────────────────────
+  getPX(t, e) {
+    const s = this.m_Book.papers, i = s.length;
+    let n = 0;
+    const o = s.length / 2 - 1, a = s.length / 2;
+    for (let f = 0; f < i; f++)
+      n += 0 * e, f === o && (n += 0 * this.m_BindingMidSpace / 2), f === a && (n += 0 * this.m_BindingMidSpace / 2);
+    const h = this.getStackHeight(t) - e / 2, m = this.getStackZ(h), l = 180 + m, d = F(m, l, 0) * tt;
+    return new c.Vector3(
+      Math.cos(d) * this.m_BindingRadius,
+      Math.sin(d) * this.m_BindingRadius,
+      0
+    ).x;
+  }
+  // ── updatePaperPosition ───────────────────────────────────────────────
+  updatePaperPosition(t) {
+    const e = this.m_Book.papers, s = e.length;
+    let i = 0;
+    const n = e.length / 2 - 1, o = e.length / 2;
+    for (let x = 0; x < s; x++) {
+      const y = e[x];
+      y.updateTime();
+      const S = y.zTime, v = y.thickness;
+      i += S * v, x === n && (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), m = 180 + this.getStackZ(a + i - this.m_StackHeight);
+    let l = t.zTime, _ = F(h, m, l);
+    const p = _ * tt, d = new c.Vector3(
+      Math.cos(p) * this.m_BindingRadius,
+      Math.sin(p) * this.m_BindingRadius,
+      0
+    );
+    d.z = t.margin;
+    let u = e[Math.floor(s / 2)].size.x, f = this.m_BindingMidSpace, g = Math.sqrt(u * u - f * f), w = Math.asin(g / u) * it - 90;
+    if (t.index < Math.floor(s / 2)) {
+      let x = 0;
+      if (this.m_Book.alignToGround) {
+        u = e[0].size.x;
+        const y = this.m_StackHeight / 2;
+        f = et(i, 0, y) - y, g = Math.sqrt(u * u - f * f), x = (Math.asin(g / u) * it - 90) * 2;
+      }
+      _ = F(w, -x, l);
+    } else {
+      let x = 0;
+      if (this.m_Book.alignToGround) {
+        u = e[0].size.x;
+        const y = this.m_StackHeight / 2;
+        f = y - et(i, y, y * 2), g = Math.sqrt(u * u - f * f), x = (Math.asin(g / u) * it - 90) * 2;
+      }
+      _ = F(x, -w, l);
+    }
+    t.transform.position.copy(d), t.transform.quaternion.setFromEuler(
+      new c.Euler(0, 0, _ * tt)
+    );
+  }
+  // ── getStackHeight ────────────────────────────────────────────────────
+  getStackHeight(t) {
+    const e = this.m_Book.papers;
+    let s = 0;
+    const i = e.length;
+    for (let n = t; n < i; n++)
+      s += e[n].thickness;
+    return t < Math.floor(i / 2) && (s += this.m_BindingMidSpace), s;
+  }
+  // ── getStackZ ─────────────────────────────────────────────────────────
+  getStackZ(t) {
+    t = et(t, 0, this.m_StackHeight);
+    const e = t - this.m_StackHeight * 0.5;
+    return Math.asin(e / this.m_BindingRadius) * it;
+  }
+  // ── 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 n = this.m_StapleThickness * 0.5, o = t[0].thickness, a = this.m_Root.matrixWorld.clone(), h = t.length;
+    for (let m = 0; m < h; m++) {
+      const l = t[m], _ = l.transform, p = l.meshData.pattern, d = l.meshData.baseVertices, u = p.baseXArray, f = p.baseZArray, g = u.length, w = f.length, B = this.m_BindingVertexCount + 1, x = l.thickness, y = p.xNoneSeamIndexes, S = _.position.clone();
+      let v = m, Z = n;
+      m >= Math.floor(h / 2) && (v = h - m - 1, Z *= -1);
+      const O = (o + x) * 0.5 + x * (v - 1), z = _.matrixWorld.clone().invert().multiply(a), N = v / (h / 2);
+      i = this.m_BindingRadius * F(0.45, 0.65, 1 - N);
+      for (let D = 0; D < w; D++) {
+        const C = f[D], V = new c.Vector3(0, 0, S.z + C), U = S.clone();
+        U.z += C;
+        const k = l.getDirection(C).multiplyScalar(i).add(U.clone());
+        if (m === 0 && D === 0) {
+          const A = t[h - 1], H = A.transform.position.clone().clone();
+          H.z += C;
+          const T = A.getDirection(C).multiplyScalar(i).add(H);
+          s = k.clone().sub(T).normalize(), e = new c.Vector3(
+            -s.y,
+            s.x,
+            0
+          ).normalize().negate();
+          const I = Math.atan2(e.y, e.x) * it;
+          this.stapleMesh.rotation.set(0, 0, I * tt);
+        }
+        v > 0 && V.add(e.clone().multiplyScalar(O));
+        const Q = D * g;
+        d[Q] = V.clone().applyMatrix4(z), V.add(s.clone().multiplyScalar(Z));
+        const G = V.clone().applyMatrix4(z), $ = k.clone().applyMatrix4(z), j = U.clone().applyMatrix4(z);
+        d[Q + y[1]] = G;
+        for (let A = 2; A < B; A++) {
+          const M = jt(1, B, A);
+          d[Q + y[A]] = Xt(
+            G,
+            $,
+            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 He {
+  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 Xe extends Pe {
+  constructor() {
+    super(...arguments), this.quality = 3, this.stapleSetup = new ze();
+  }
+  createBound(t, e, s, i) {
+    return new Ae(
+      this.quality,
+      this.stapleSetup,
+      t,
+      e
+    );
+  }
+}
+export {
+  xe as AnimationCurve,
+  yt as AutoTurnDirection,
+  pe as AutoTurnMode,
+  rt as AutoTurnSetting,
+  Me as AutoTurnSettingCurveTimeMode,
+  ge as AutoTurnSettingMode,
+  Nt as AutoTurnSettings,
+  Ut as Book,
+  Pe as BookBinding,
+  Le as BookBound,
+  Ue as BookContent,
+  E as BookDirection,
+  Ze as BookHeightException,
+  de as BookRenderer,
+  ut as Cylinder,
+  me as MeshFactory,
+  Ne as PageContent,
+  he as Paper,
+  wt as PaperBorder,
+  Dt as PaperMaterialData,
+  Zt as PaperMeshData,
+  fe as PaperMeshDataPool,
+  Fe as PaperMeshUtility,
+  st as PaperNode,
+  le as PaperNodeMargin,
+  ye as PaperPattern,
+  Pt as PaperSeam,
+  ht as PaperSetup,
+  gt as PaperUVMargin,
+  ue as RendererFactory,
+  Lt as SpritePageContent2,
+  Xe as StapleBookBinding,
+  Ae as StapleBookBound,
+  ze as StapleSetup
+};