postext-folio 0.52.1 → 0.52.3

package/dist/pageFlip.js

@@ -1,914 +1,23 @@
-import { BoxGeometry, BufferAttribute, BufferGeometry, Color, CustomBlending, DepthTexture, DirectionalLight, DoubleSide, Group, HalfFloatType, LinearMipmapLinearFilter, MaxEquation, Mesh, MeshPhysicalMaterial, MeshStandardMaterial, LinearFilter, Matrix4, NeutralToneMapping, OneFactor, OrthographicCamera, PCFShadowMap, PerspectiveCamera, Plane, PlaneGeometry, PMREMGenerator, Raycaster, Scene, ShaderChunk, ShaderMaterial, ShadowMaterial, SRGBColorSpace, Texture, TextureLoader, Vector2, Vector3, Vector4, WebGLRenderer, WebGLRenderTarget, } from "three";
-import { EffectComposer } from "three/examples/jsm/postprocessing/EffectComposer.js";
-import { OutputPass } from "three/examples/jsm/postprocessing/OutputPass.js";
-import { RenderPass } from "three/examples/jsm/postprocessing/RenderPass.js";
-import { SMAAPass } from "three/examples/jsm/postprocessing/SMAAPass.js";
-import { resolveFolioConfig } from "postext";
-import { along, BINDINGS, gutterOcclusion, profiles, stackGeometry, topAt } from "./bookGeometry.js";
-import { environment } from "./environments.js";
-import { pagePaper, paperSpec } from "./paper.js";
-import { loadDeskMaps } from "./deskTextures.js";
-import { ATLAS_MAX, MAX_PAGE_VIDEOS, VideoAtlas } from "./videoAtlas.js";
-import { cachedDesk, cachedRelief } from "./procedural.js";
-import { Loupe } from "./loupe.js";
-/** Columns and rows of a leaf's mesh: fine enough for a tight roll. */
-const NX = 96;
-/** How far a leaf's folded paper stays over its own paper beneath it. */
-const OWN_GAP = 1.2;
-/** How much higher than at rest a leaf in the air stays over a block. */
-const BLOCK_GAP = 1.5;
-const NY = 120;
-/** Columns of a page lying open (its curve runs across only). */
-const NX_OPEN = 72;
-/** Vertical field of view. */
-const FOV = 24;
-/** Radius of the roll at mid-turn for 90 g/m² offset, against the page's width. */
-const ROLL = 0.11;
-/** Milliseconds one leaf takes to turn. */
-const DURATION = 1000;
-/** A jump of more pages than this is made in one move: the block of
- *  leaves in between is lifted together and laid over on the other side,
- *  instead of every leaf turning on its own. */
-export const BLOCK_PAGES = 10;
-/** How long a block of leaves takes to go over (ms), a little longer for
- *  a thicker one. */
-const BLOCK_DURATION = 1150;
-/** A page is taken by its outer part only: from this fraction of its
- *  width from the spine out to the fore-edge (#494). */
-const GRIP = 0.5;
-/** A leaf follows the one before it once that one is this far through its turn. */
-const GAP = 0.14;
-// Ambient occlusion from the book's own shape: each frame the book is
-// drawn, seen from straight above, into a height map: channel r the
-// highest of everything (blocks, covers, open pages, leaves), channel g the
-// leaves in the air alone. A point is occluded by paper rising round it,
-// more the nearer and higher it is: the book's contact shadow on the desk
-// and the dark under a lifted leaf. The open pages read only the leaves'
-// channel (their gutter is worked out from the cross-section).
-const OCCLUSION = /* glsl */ `
-  uniform sampler2D uShadowMap;
-  uniform vec4 uShadowBox;
-  uniform float uShadowOn;
-  uniform float uOccRadius;
-  uniform float uOccBias;
-  float casterAt(vec2 s, float channel) {
-    vec2 uv = (s - uShadowBox.xy) / uShadowBox.zw;
-    if (uv.x < 0.0 || uv.y < 0.0 || uv.x > 1.0 || uv.y > 1.0) return -1e4;
-    vec4 t = texture2D(uShadowMap, uv);
-    return (channel > 0.5 ? t.g : t.r) - 10.0;
-  }
-  // Horizon-based: in each of 8 directions, the highest paper seen from p
-  // (as an elevation angle) hides that much of the sky: sin(horizon) of a
-  // cosine-weighted slice.
-  float bookOcclusion(vec3 p, float channel) {
-    if (uShadowOn < 0.5) return 0.0;
-    float spin = fract(sin(dot(gl_FragCoord.xy, vec2(12.9898, 78.233))) * 43758.5453);
-    float occ = 0.0;
-    for (int d = 0; d < 8; d++) {
-      float a = (float(d) + spin) * 0.785398;
-      vec2 dir = vec2(cos(a), sin(a));
-      float horizon = 0.0;
-      for (int i = 0; i < 4; i++) {
-        float t = (float(i) + 0.25 + 0.5 * spin) / 4.0;
-        float r = t * t * uOccRadius + 1.0;
-        float h = casterAt(p.xy + r * dir, channel) - p.z - uOccBias;
-        horizon = max(horizon, h / sqrt(h * h + r * r));
-      }
-      occ += horizon;
-    }
-    return occ / 8.0;
-  }
-  // How far the reflection seen at p runs under paper: its ray marched
-  // out through the height map (a lifted leaf hides what it would mirror,
-  // and so does the leaf's own roll over the inside of its curl). The
-  // march starts a few px out, past the paper round p itself. Its steps
-  // are shifted a little from pixel to pixel: at fixed steps the leaf's
-  // outline was cut in at each of them, a row of teeth (#483).
-  float reflectionOcclusion(vec3 p, vec3 r, float channel) {
-    if (uShadowOn < 0.5) return 0.0;
-    // Interleaved gradient noise: neighbours take evenly spread shifts.
-    float spin = fract(52.9829189 * fract(dot(gl_FragCoord.xy, vec2(0.06711056, 0.00583715))));
-    float hidden = 0.0;
-    for (int i = 0; i < 8; i++) {
-      float s = (float(i) + spin) / 8.0;
-      float t = 6.0 + s * s * uOccRadius * 2.0;
-      vec3 q = p + r * t;
-      hidden = max(hidden, smoothstep(0.0, 4.0, casterAt(q.xy, channel) - q.z - uOccBias));
-    }
-    return hidden;
-  }
-`;
-/** Declares the book position varying in a vertex shader and sets it:
- *  the world position with the mirror of a right-bound book undone. */
-const BOOK_POS_PARS = "uniform float uSign;\nvarying vec3 vBookPos;";
-const BOOK_POS = "vBookPos = (modelMatrix * vec4(transformed, 1.0)).xyz;\nvBookPos.x *= uSign;";
-// The casters lie outside the stage, in the book's own coordinates (as
-// `vBookPos` reads the map): no mirror here (#334).
-const CASTER_VERTEX = /* glsl */ `
-  varying float vZ;
-  void main() {
-    vec4 w = modelMatrix * vec4(position, 1.0);
-    vZ = w.z;
-    gl_Position = projectionMatrix * viewMatrix * vec4(w.xy, 0.0, 1.0);
-  }
-`;
-const CASTER_FRAGMENT = /* glsl */ `
-  uniform float uLeaf;
-  varying float vZ;
-  void main() {
-    gl_FragColor = vec4(vZ + 10.0, uLeaf * (vZ + 10.0), 0.0, 1.0);
-  }
-`;
-/** The occlusion uniforms every receiving material shares (same objects). */
-const occlusionUniforms = {
-    uShadowMap: { value: null },
-    uShadowBox: { value: new Vector4(0, 0, 1, 1) },
-    uShadowOn: { value: 0 },
-    uOccRadius: { value: 60 },
-    uOccBias: { value: 1 },
-};
-// The key light's soft shadow, each of its samples compared against the
-// receiver's own plane carried to that sample (receiver-plane depth bias):
-// three.js compares them all at the receiver's depth, so a sheet steep to
-// the light, a leaf in the air, found itself nearer the light a few texels
-// away and fell in its own shadow (#330). The shadow is kept (`keyShadow`)
-// so the reflections can be cut with it too.
-const SHADOW_PCF_HEAD = "float getShadow( sampler2DShadow shadowMap, vec2 shadowMapSize, float shadowIntensity, float shadowBias, float shadowRadius, vec4 shadowCoord ) {";
-const SHADOW_PCF = /* glsl */ `
-  ${SHADOW_PCF_HEAD}
-    shadowCoord.xyz /= shadowCoord.w;
-    shadowCoord.z += shadowBias;
-    // How the receiver's depth in the map runs with the map's uv.
-    vec3 sx = dFdx(shadowCoord.xyz);
-    vec3 sy = dFdy(shadowCoord.xyz);
-    float det = sx.x * sy.y - sx.y * sy.x;
-    vec2 slope = abs(det) > 1e-12 ? vec2(sy.y * sx.z - sx.y * sy.z, sx.x * sy.z - sy.x * sx.z) / det : vec2(0.0);
-    float shadow = 1.0;
-    if (shadowCoord.x >= 0.0 && shadowCoord.x <= 1.0 && shadowCoord.y >= 0.0 && shadowCoord.y <= 1.0 && shadowCoord.z <= 1.0) {
-      float radius = shadowRadius / shadowMapSize.x;
-      float phi = interleavedGradientNoise(gl_FragCoord.xy) * PI2;
-      shadow = 0.0;
-      for (int i = 0; i < 5; i++) {
-        vec2 o = vogelDiskSample(i, 5, phi) * radius;
-        // Held in where the plane runs nearly along the light.
-        float dz = clamp(dot(slope, o), -0.05, 0.05);
-        shadow += texture(shadowMap, vec3(shadowCoord.xy + o, shadowCoord.z + dz));
-      }
-      shadow *= 0.2;
-    }
-    keyShadow = shadow;
-    return mix(1.0, shadow, shadowIntensity);
-  }
-`;
-const SHADOW_PARS = (() => {
-    const chunk = ShaderChunk.shadowmap_pars_fragment;
-    const start = chunk.indexOf(SHADOW_PCF_HEAD);
-    const end = chunk.indexOf("#elif defined( SHADOWMAP_TYPE_VSM )", start);
-    // Another three.js: its own shadows (no receiver plane).
-    const pars = start < 0 || end < 0 ? chunk : chunk.slice(0, start) + SHADOW_PCF + chunk.slice(end);
-    return `float keyShadow = 1.0;\n${pars}`;
-})();
-/** How much of the environment's reflection the key's shadow takes away:
- *  the key stands where the environment's brightest emitter is, so what
- *  hides it from a point hides that emitter's reflection too. */
-function keySpecular(occlusion = "1.0") {
-    return /* glsl */ `{
-  float keySpec = mix(1.0, keyShadow, 0.85) * (${occlusion});
-  reflectedLight.indirectSpecular *= keySpec;
-  #ifdef USE_CLEARCOAT
-    clearcoatSpecularIndirect *= keySpec;
-  #endif
-  #ifdef USE_SHEEN
-    sheenSpecularIndirect *= keySpec;
-  #endif
-}`;
-}
-/** Gives a material the key's shadow on its own plane. */
-function keyShadowed(fragmentShader) {
-    return fragmentShader.replace("#include <shadowmap_pars_fragment>", SHADOW_PARS);
-}
-/** A caster's own copy of a mesh's shape. The height map is drawn before
- *  the main view, and three.js uploads a geometry once per frame number,
- *  which the key's shadow pass at the end of the last main view had
- *  already taken: a caster sharing a leaf's geometry drew the leaf where
- *  it lay a frame before, and a leaf moving down was shaded by its own
- *  old self, moving up it was not (#488). */
-function casterGeometry(source) {
-    const g = new BufferGeometry();
-    g.setAttribute("position", source.attributes.position.clone());
-    if (source.index)
-        g.setIndex(source.index.clone());
-    return g;
-}
-/** Brings a caster's copy to its mesh's shape as laid out this frame. */
-function syncCaster(caster, source) {
-    const to = caster.geometry.attributes.position;
-    to.array.set(source.attributes.position.array);
-    to.needsUpdate = true;
-}
-function casterMaterial(leaf) {
-    return new ShaderMaterial({
-        vertexShader: CASTER_VERTEX,
-        fragmentShader: CASTER_FRAGMENT,
-        side: DoubleSide,
-        blending: CustomBlending,
-        blendEquation: MaxEquation,
-        blendEquationAlpha: MaxEquation,
-        blendSrc: OneFactor,
-        blendDst: OneFactor,
-        depthTest: false,
-        depthWrite: false,
-        uniforms: { uLeaf: { value: leaf ? 1 : 0 } },
-    });
-}
-/** A standard material (the desk, the covers) with the book's occlusion
- *  on its ambient light. */
-function occluded(m, sign) {
-    m.onBeforeCompile = (shader) => {
-        Object.assign(shader.uniforms, occlusionUniforms, { uSign: { value: sign } });
-        shader.vertexShader = shader.vertexShader
-            .replace("#include <common>", `#include <common>\n${BOOK_POS_PARS}`)
-            .replace("#include <begin_vertex>", `#include <begin_vertex>\n${BOOK_POS}`);
-        shader.fragmentShader = keyShadowed(shader.fragmentShader)
-            .replace("#include <common>", `#include <common>\nvarying vec3 vBookPos;\n${OCCLUSION}`)
-            .replace("#include <aomap_fragment>", "#include <aomap_fragment>\n{ float occ = 1.0 - bookOcclusion(vBookPos, 0.0); reflectedLight.indirectDiffuse *= occ; reflectedLight.indirectSpecular *= occ; }\n" + keySpecular());
-    };
-    return m;
-}
-/** What lies behind the leaves in the air (#484): the scene drawn without
- *  the translucent leaves (colour, mipmapped, and depth), shared by every
- *  page. `uBehindSize`: the screen in device px; `uBehindClip`: the
- *  camera's near and far planes; `uBehindScale`: texels of that picture
- *  per book unit at a view depth of 1; `uBehindFloor`: how far (book
- *  units) the sheet's fibres spread even what touches it. */
-const behindUniforms = {
-    uBehind: { value: null },
-    uBehindDepth: { value: null },
-    uBehindOn: { value: 0 },
-    uBehindSize: { value: new Vector2(1, 1) },
-    uBehindClip: { value: new Vector2(1, 2) },
-    uBehindScale: { value: 1 },
-    uBehindFloor: { value: 1 },
-};
-/**
- * A page's material: three.js's physical (PBR) material lit by the
- * environment and the key light, the printed page on each face, the
- * paper's shade, finish (roughness, a clear coat on coated stock, a fibre
- * sheen on uncoated) and relief (a normal map), and the print on the other
- * side showing faintly through thin paper. Ambient light is cut by the
- * gutter's occlusion (a vertex attribute, from the book's cross-section)
- * and by lifted leaves nearby.
- */
-function pageMaterial(mirror, sign) {
-    const m = new MeshPhysicalMaterial({ side: DoubleSide, roughness: 0.85 });
-    const uniforms = {
-        uFront: { value: null },
-        uBack: { value: null },
-        uHasFront: { value: 0 },
-        uHasBack: { value: 0 },
-        uMirror: { value: mirror ? 1 : 0 },
-        uShowThrough: { value: 0 },
-        uUnder: { value: null },
-        uHasUnder: { value: 0 },
-        uUnderK: { value: 0 },
-        uTransmit: { value: 0 },
-        uPaper: { value: new Color(1, 1, 1) },
-        uLeafOcc: { value: 0.45 },
-        uOccBias: { value: 6 },
-        uVideo: { value: null },
-        uVidTexel: { value: new Vector2(1, 1) },
-        uVidCount: { value: 0 },
-        uVidOA: { value: Array.from({ length: MAX_PAGE_VIDEOS }, () => new Vector4()) },
-        uVidDF: { value: Array.from({ length: MAX_PAGE_VIDEOS }, () => new Vector4()) },
-        uVidRect: { value: Array.from({ length: MAX_PAGE_VIDEOS }, () => new Vector4()) },
-        uReflection: { value: null },
-        uReflectionOn: { value: 0 },
-        uReflectionSize: { value: new Vector2(1, 1) },
-        uReflectionNormal: { value: new Vector3(0, 0, 1) },
-    };
-    m.userData.uniforms = uniforms;
-    m.onBeforeCompile = (shader) => {
-        Object.assign(shader.uniforms, occlusionUniforms, behindUniforms, uniforms, { uSign: { value: sign } });
-        shader.vertexShader = shader.vertexShader
-            .replace("#include <common>", `#include <common>
-        attribute float ao;
-        varying float vAo;
-        varying vec2 vPageUv;
-        ${BOOK_POS_PARS}`)
-            .replace("#include <begin_vertex>", `#include <begin_vertex>
-        vAo = ao;
-        vPageUv = uv;
-        ${BOOK_POS}`);
-        shader.fragmentShader = keyShadowed(shader.fragmentShader)
-            .replace("#include <common>", `#include <common>
-        uniform sampler2D uFront;
-        uniform sampler2D uBack;
-        uniform float uHasFront;
-        uniform float uHasBack;
-        uniform float uMirror;
-        uniform float uShowThrough;
-        uniform sampler2D uUnder;
-        uniform float uHasUnder;
-        uniform float uUnderK;
-        uniform float uTransmit;
-        uniform sampler2D uBehind;
-        uniform sampler2D uBehindDepth;
-        uniform float uBehindOn;
-        uniform vec2 uBehindSize;
-        uniform vec2 uBehindClip;
-        uniform float uBehindScale;
-        uniform float uBehindFloor;
-        // The print of both faces at this point: what light coming
-        // through the sheet passes on its way.
-        vec3 transInk = vec3(1.0);
-        uniform vec3 uPaper;
-        uniform float uLeafOcc;
-        uniform float uSign;
-        uniform sampler2D uVideo;
-        uniform vec2 uVidTexel;
-        uniform float uVidCount;
-        uniform vec4 uVidOA[${MAX_PAGE_VIDEOS}];
-        uniform vec4 uVidDF[${MAX_PAGE_VIDEOS}];
-        uniform vec4 uVidRect[${MAX_PAGE_VIDEOS}];
-        uniform sampler2D uReflection;
-        uniform float uReflectionOn;
-        uniform vec2 uReflectionSize;
-        uniform vec3 uReflectionNormal;
-        varying float vAo;
-        varying vec2 vPageUv;
-        varying vec3 vBookPos;
-        ${OCCLUSION}`)
-            .replace("#include <map_fragment>", `{
-          // 0 no page, 1 its image, 2 blank paper; uv.x runs from the spine.
-          bool front = gl_FrontFacing;
-          float has = front ? uHasFront : uHasBack;
-          float u = uMirror > 0.5 ? 1.0 - vPageUv.x : vPageUv.x;
-          vec2 uvF = vec2(u, vPageUv.y);
-          vec2 uvB = vec2(1.0 - u, vPageUv.y);
-          vec3 ink = uPaper;
-          if (has > 0.5 && has < 1.5) ink = front ? texture2D(uFront, uvF).rgb : texture2D(uBack, uvB).rgb;
-          // The videos playing on this face, printed over their posters:
-          // the point of the page (from its top left corner) in each
-          // picture's own frame, which may lie turned on the page, then in
-          // its slot of the atlas (kept half a texel inside it, clear of
-          // the next slot).
-          vec2 tuv = front ? uvF : uvB;
-          for (int i = 0; i < ${MAX_PAGE_VIDEOS}; i++) {
-            if (float(i) >= uVidCount) break;
-            vec4 oa = uVidOA[i];
-            vec4 df = uVidDF[i];
-            if ((df.z < 1.5) != front) continue;
-            vec2 p = vec2(tuv.x, 1.0 - tuv.y) - oa.xy;
-            vec2 st = vec2(dot(p, oa.zw) / dot(oa.zw, oa.zw), dot(p, df.xy) / dot(df.xy, df.xy));
-            if (st.x >= 0.0 && st.x <= 1.0 && st.y >= 0.0 && st.y <= 1.0) {
-              vec4 r = uVidRect[i];
-              vec2 v = clamp(r.xy + st * r.zw, r.xy + 0.5 * uVidTexel, r.xy + r.zw - 0.5 * uVidTexel);
-              ink = texture2D(uVideo, vec2(v.x, 1.0 - v.y)).rgb;
-            }
-          }
-          // The other side's print, seen through the sheet (the same point
-          // of paper, so mirrored as it should be).
-          float other = front ? uHasBack : uHasFront;
-          vec3 through = vec3(1.0);
-          if ((uShowThrough > 0.0 || uTransmit > 0.0) && other > 0.5 && other < 1.5) {
-            through = front ? texture2D(uBack, uvB).rgb : texture2D(uFront, uvF).rgb;
-          }
-          transInk = ink * through;
-          if (uShowThrough > 0.0) ink *= mix(vec3(1.0), through, uShowThrough);
-          // The page lying under an open page: its print comes through the
-          // whole sheet (the fibres spread it by a fraction of a millimetre,
-          // finer than the page's own texels: a softer sample would blur
-          // a page seen small to grey).
-          if (uHasUnder > 0.5 && uUnderK > 0.0) {
-            vec3 under = texture2D(uUnder, front ? uvF : uvB).rgb;
-            ink *= mix(vec3(1.0), under, uUnderK);
-          }
-          diffuseColor.rgb *= ink;
-        }`)
-            .replace("#include <aomap_fragment>", `#include <aomap_fragment>
-        {
-          // A leaf's own roll counts among the leaves it is occluded by:
-          // held to what its open side would let in.
-          float occ = vAo * (1.0 - uLeafOcc * bookOcclusion(vBookPos, 1.0));
-          reflectedLight.indirectDiffuse *= occ;
-          reflectedLight.indirectSpecular *= mix(1.0, occ, 0.85);
-        }
-        // The reflection's ray, in book coordinates.
-        vec3 reflected = (vec4(reflect(-geometryViewDir, normal), 0.0) * viewMatrix).xyz;
-        reflected.x *= uSign;
-        // A mirrored leaf stands for what it hides itself.
-        ${keySpecular("1.0 - 0.85 * (uReflectionOn > 0.5 ? 0.0 : reflectionOcclusion(vBookPos, reflected, 1.0))")}
-        #ifdef USE_CLEARCOAT
-        if (uReflectionOn > 0.5) {
-          // The leaves in the air, mirrored in a gloss page: where one is
-          // seen, it takes the place of the environment it hides, through
-          // the coating's Fresnel and the paper's own. A plane holds only
-          // where the page lies in it: the mirror fades up the gutter.
-          vec2 st = gl_FragCoord.xy / uReflectionSize;
-          vec4 seen = texture2D(uReflection, vec2(1.0 - st.x, st.y));
-          float lies = smoothstep(0.97, 0.995, abs(dot((vec4(normalize(vNormal), 0.0) * viewMatrix).xyz, uReflectionNormal)));
-          float a = seen.a * lies;
-          vec3 leaf = seen.rgb * lies;
-          clearcoatSpecularIndirect = clearcoatSpecularIndirect * (1.0 - a)
-            + leaf * EnvironmentBRDF(geometryClearcoatNormal, geometryViewDir, material.clearcoatF0, material.clearcoatF90, material.clearcoatRoughness);
-          reflectedLight.indirectSpecular = reflectedLight.indirectSpecular * (1.0 - a)
-            + leaf * EnvironmentBRDF(geometryNormal, geometryViewDir, material.specularColor, material.specularF90, material.roughness);
-        }
-        #endif
-        if (uBehindOn > 0.5 && uTransmit > 0.0) {
-          // Thin paper in the air lets through the light behind it (#484):
-          // what lies there on screen, seen through the print of both
-          // faces. The sheet scatters what it lets through about evenly
-          // (near Lambertian), so a thing a gap behind it is spread over
-          // about twice that gap: sharp where the leaf touches the page
-          // under it, a soft glow a few millimetres off. A page close
-          // under it is lit only through the leaf, so its print comes
-          // back at about half the leaf's transmittance (1 − opacity, as
-          // the open page shows the one under it); what lies further, out
-          // of the leaf's shade, at the whole of it. Stronger and sharper,
-          // the page under a leaf about to land read as lying over it
-          // (#492). What it lets through it does not reflect.
-          vec2 st = gl_FragCoord.xy / uBehindSize;
-          float depth = texture2D(uBehindDepth, st).x;
-          float zBehind = uBehindClip.x * uBehindClip.y / (uBehindClip.y - depth * (uBehindClip.y - uBehindClip.x));
-          float gap = max(0.0, zBehind - vViewPosition.z);
-          float spread = (uBehindFloor + 2.0 * gap) * uBehindScale / vViewPosition.z;
-          vec4 seen = textureLod(uBehind, st, log2(max(1.0, 2.0 * spread)));
-          float carried = uTransmit * mix(0.5, 1.0, smoothstep(0.0, 8.0 * uBehindFloor, gap));
-          float lost = carried * seen.a;
-          reflectedLight.directDiffuse *= 1.0 - lost;
-          reflectedLight.indirectDiffuse = reflectedLight.indirectDiffuse * (1.0 - lost) + carried * seen.rgb * transInk;
-        }`);
-    };
-    return m;
-}
-/** The uniforms every page block's edge material shares: book units per
- *  mm, and how strongly the cut face is relieved (uncoated stock shows
- *  its fibres; a coated sheet is cut cleaner). */
-const edgeUniforms = {
-    uEdgeK: { value: 1 },
-    uEdgeRelief: { value: 1 },
-};
-// The cut face of a page block, as a height field in mm over (leaf, mm
-// along the cut): every leaf a rounded ridge standing a hair proud of or
-// behind its neighbours (sheets are never quite in line), the sections
-// and the bundles the knife took together a little out of line with the
-// next, and the faint streaks the guillotine drags across the block. Each
-// scale fades out where it is finer than a pixel, so the face never
-// shimmers. The relief bends the normal (bump mapping from the screen-
-// space derivatives of the field), so the face catches a grazing light.
-const EDGE_RELIEF = /* glsl */ `
-  uniform float uEdgeK;
-  uniform float uEdgeRelief;
-  varying float vRun;
-  float eHash(float n) { return fract(sin(n * 127.1) * 43758.5453); }
-  float eHash2(vec2 p) { return fract(sin(dot(p, vec2(127.1, 311.7))) * 43758.5453); }
-  float eNoise(vec2 p) {
-    vec2 i = floor(p);
-    vec2 f = fract(p);
-    vec2 u = f * f * (3.0 - 2.0 * f);
-    return mix(mix(eHash2(i), eHash2(i + vec2(1.0, 0.0)), u.x), mix(eHash2(i + vec2(0.0, 1.0)), eHash2(i + vec2(1.0, 1.0)), u.x), u.y);
-  }
-  // fade: x = the leaves, y = the bundles, z = the fine knife marks.
-  float edgeHeight(vec2 lv, vec3 fade) {
-    float id = floor(lv.x);
-    float ridge = sin(fract(lv.x) * PI);
-    float proud = eHash(id) - 0.5 + 0.8 * (eNoise(vec2(id * 0.37, lv.y * 0.12)) - 0.5);
-    float leaf = (0.45 * ridge + proud) * 0.04 * fade.x;
-    float bundle = (eNoise(vec2(lv.x / 5.0, lv.y * 0.03)) - 0.5) * 0.12 * fade.y
-      + (eNoise(vec2(lv.x / 24.0 + 7.0, lv.y * 0.02)) - 0.5) * 0.18;
-    float knife = (eNoise(vec2(lv.y * 0.7, lv.x / 90.0)) - 0.5) * 0.035
-      + (eNoise(vec2(lv.y * 3.0, lv.x / 40.0)) - 0.5) * 0.006 * fade.z;
-    return leaf + bundle + knife;
-  }
-  vec3 edgeNormal(vec3 surfPos, vec3 n, vec2 dH, float faceDir) {
-    vec3 sx = dFdx(surfPos);
-    vec3 sy = dFdy(surfPos);
-    vec3 r1 = cross(sy, n);
-    vec3 r2 = cross(n, sx);
-    float det = dot(sx, r1) * faceDir;
-    vec3 grad = sign(det) * (dH.x * r1 + dH.y * r2);
-    return normalize(abs(det) * n - grad);
-  }
-`;
-/** The page block's edges: paper with a fine line between leaves (fading
- *  to their average where the lines are finer than a pixel), its cut face
- *  in relief. */
-function edgeMaterial(sign, bands, paper) {
-    const m = new MeshStandardMaterial({ side: DoubleSide, roughness: 0.92 });
-    if (paper)
-        m.color.copy(paper);
-    const band = { uBoardLo: { value: bands?.lo ?? -1 }, uBoardHi: { value: bands?.hi ?? 2 }, uBoardColor: { value: bands?.color ?? new Color(0, 0, 0) } };
-    m.onBeforeCompile = (shader) => {
-        Object.assign(shader.uniforms, occlusionUniforms, edgeUniforms, band, { uSign: { value: sign } });
-        shader.vertexShader = shader.vertexShader
-            .replace("#include <common>", `#include <common>\nattribute float layer;\nattribute float lambda;\nattribute float run;\nvarying float vLayer;\nvarying float vLambda;\nvarying float vRun;\n${BOOK_POS_PARS}`)
-            .replace("#include <begin_vertex>", `#include <begin_vertex>\nvLayer = layer;\nvLambda = lambda;\nvRun = run;\n${BOOK_POS}`);
-        shader.fragmentShader = keyShadowed(shader.fragmentShader)
-            .replace("#include <common>", `#include <common>\nuniform float uBoardLo;\nuniform float uBoardHi;\nuniform vec3 uBoardColor;\nvarying float vLayer;\nvarying float vLambda;\nvarying vec3 vBookPos;\n${OCCLUSION}\n${EDGE_RELIEF}`)
-            .replace("#include <normal_fragment_maps>", `{
-          vec2 lv = vec2(vLayer, vRun / uEdgeK);
-          vec2 dx = dFdx(lv);
-          vec2 dy = dFdy(lv);
-          float wl = fwidth(vLayer);
-          vec3 fade = vec3(
-            1.0 - smoothstep(0.3, 0.8, wl),
-            1.0 - smoothstep(2.0, 5.0, wl),
-            1.0 - smoothstep(0.05, 0.15, fwidth(lv.y))
-          );
-          float h0 = edgeHeight(lv, fade);
-          vec2 dH = vec2(edgeHeight(lv + dx, fade) - h0, edgeHeight(lv + dy, fade) - h0) * uEdgeK * uEdgeRelief;
-          if (vLambda >= uBoardLo && vLambda <= uBoardHi) normal = edgeNormal(-vViewPosition, normal, dH, faceDirection);
-        }`)
-            .replace("#include <map_fragment>", `{
-          float w = fwidth(vLayer);
-          float d = abs(fract(vLayer) - 0.5) * 2.0;
-          float line = smoothstep(0.55 - w, 0.95 + w, d);
-          float fine = clamp(w * 1.5, 0.0, 1.0);
-          diffuseColor.rgb *= 1.0 - mix(0.22 * line, 0.08, fine);
-          // The bundles' sheets are never quite one shade.
-          diffuseColor.rgb *= 1.0 + 0.06 * uEdgeRelief * (eNoise(vec2(vLayer / 9.0, 3.0)) - 0.5);
-          // A board lying in the block (the book's own cover) shows its
-          // own edge, not paper.
-          if (vLambda < uBoardLo || vLambda > uBoardHi) diffuseColor.rgb = uBoardColor;
-        }`)
-            .replace("#include <aomap_fragment>", "#include <aomap_fragment>\nreflectedLight.indirectDiffuse *= 1.0 - bookOcclusion(vBookPos, 0.0);");
-    };
-    return m;
-}
-const ease = (t) => (t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2);
-const easeOut = (t) => 1 - Math.pow(1 - t, 3);
-const smooth = (a, b, x) => {
-    const t = Math.min(1, Math.max(0, (x - a) / (b - a)));
-    return t * t * (3 - 2 * t);
-};
-/**
- * The stock a publisher would print a book of `pages` pages on, when its
- * settings name none: a long book goes on lighter paper, a very long one
- * on bible paper (2,000 pages make a volume about 4.5 cm thick, not 11).
- * Settings that name a stock, a grammage or a bulk are kept as they are.
- */
-export function withStockForExtent(folio, pages) {
-    const paper = folio?.paper;
-    if (paper?.type !== undefined || paper?.grammage !== undefined || paper?.bulk !== undefined)
-        return folio;
-    if (pages > 1000)
-        return { ...folio, paper: { ...paper, type: "bible" } };
-    if (pages > 600)
-        return { ...folio, paper: { ...paper, grammage: 70 } };
-    return folio;
-}
-/** The colour round the edge of a printed cover (its ground), averaged: the
- *  colour its boards and spine show when the book carries its own covers.
- *  Null when the image cannot be read. */
-function edgeColorOf(image) {
-    try {
-        const c = document.createElement("canvas");
-        c.width = c.height = 32;
-        const g = c.getContext("2d");
-        if (!g)
-            return null;
-        g.drawImage(image, 0, 0, 32, 32);
-        const d = g.getImageData(0, 0, 32, 32).data;
-        let r = 0;
-        let gr = 0;
-        let b = 0;
-        let n = 0;
-        for (let y = 0; y < 32; y++)
-            for (let x = 0; x < 32; x++) {
-                if (x > 1 && x < 30 && y > 1 && y < 30)
-                    continue;
-                const i = (y * 32 + x) * 4;
-                r += d[i];
-                gr += d[i + 1];
-                b += d[i + 2];
-                n++;
-            }
-        return new Color().setRGB(r / n / 255, gr / n / 255, b / n / 255, SRGBColorSpace);
-    }
-    catch {
-        return null;
-    }
-}
-/** The lowest the reader may orbit the view: 70° from straight above. */
-const MAX_PITCH = (70 * Math.PI) / 180;
-/** How far (radians) a leaf in mid-turn stands off the pages at the spine:
- *  barely; it is sewn there, and more reads as the leaf lifting off the
- *  book parallel to it and dropping back. */
-const LEAN = 0.02;
-/** Where column `t` (0 … 1) of a page's mesh lies across it: closer
- *  together near the spine, where the gutter bends tightest. */
-const column = (t) => Math.pow(t, 1.45);
-/** Sets a page mesh's u coordinates to its columns. */
-function spreadColumns(geometry, nx) {
-    const uv = geometry.attributes.uv;
-    for (let i = 0; i < uv.count; i++)
-        uv.setX(i, column((i % (nx + 1)) / nx));
-    uv.needsUpdate = true;
-}
-/** max(a, b), rounded over a band `k` wide (no crease where they meet). */
-function smoothMax(a, b, k) {
-    return (a + b + Math.sqrt((a - b) * (a - b) + k * k)) / 2;
-}
-/** Where arc length `signed` from the spine lies on the open book's
- *  surface (right page positive): [x, z]. */
-function surfaceAt(book, signed) {
-    const [bx, bz] = along(signed >= 0 ? book.right : book.left, Math.abs(signed));
-    return [(signed >= 0 ? 1 : -1) * bx, bz];
-}
-/**
- * How a leaf folds when the point `G` of it has been carried to `P`: the
- * paper stays flat up to a fold line, rolls round a cylinder of radius R
- * and lies over itself beyond it, back up (the page-curl cylinder). The
- * fold is square to the pull, placed so the point taken lands under the
- * hand, and never crosses the spine the leaf is sewn to. R grows as the
- * page lifts and shrinks to nothing as it lands on the other side; a
- * stiffer paper (`roll`) bends in a wider roll.
- */
-export function foldOf(G, P, W, H, roll = 1) {
-    const du = G.u - P.u;
-    const dv = G.v - P.v;
-    const D = Math.hypot(du, dv);
-    if (D < 0.5)
-        return null;
-    const n = { u: du / D, v: dv / D };
-    const q = progressFrom(G, P);
-    const R = Math.min(0.5, ROLL * roll) * W * (0.3 + 0.7 * smooth(0, 0.2, q)) * (1 - smooth(0.62, 1, q)) * Math.min(1, D / (0.1 * W));
-    // How far the paper past the fold has turned: a leaf held up by the hand
-    // stands in the air (about 110° early in the turn), and only lies back
-    // flat (180°) as it lands. Folding it flat over itself all the way (the
-    // table-paper curl) made a tent of a leaf dragged across the spine.
-    const theta = Math.PI * (0.62 + 0.38 * smooth(0.05, 1, q));
-    // The fold sits where the point taken, carried round the roll and on
-    // straight, lands over the hand: R sinθ + (c − Rθ) cosθ = c − D.
-    const arc = R * theta;
-    const k = arc > 0 ? Math.min(1, D / arc) : 0;
-    const free = (D + k * (R * Math.sin(theta) - arc * Math.cos(theta))) / (1 - Math.cos(theta));
-    let c = free;
-    for (const S of [-H / 2, H / 2])
-        c = Math.min(c, G.u * n.u + (G.v - S) * n.v);
-    if (c <= 0)
-        return null;
-    const F = { u: G.u - n.u * c, v: G.v - n.v * c };
-    // Never all at once (#502). Paper lying beyond the point taken, along
-    // the pull (a page taken by the middle of an edge and pulled across),
-    // turns over as the hand carries it away, not the moment it moves (a
-    // pixel's pull stood half the page up). A fold held off the spine short
-    // of the hand turns the less the nearer it comes to the point taken, so
-    // that it is gone, not dropped, when it reaches it.
-    let beyond = 0;
-    for (const u of [0, W])
-        for (const v of [-H / 2, H / 2])
-            beyond = Math.max(beyond, (u - G.u) * n.u + (v - G.v) * n.v);
-    const turns = (c / free) * (beyond > 0 ? smooth(0, 0.5 * beyond, D) : 1);
-    return { F, n, R, theta: theta * turns };
-}
-/** Paper `d` past the fold, round a roll of radius R and straight on at
- *  θ: how far it reaches back across the page, and how high it stands. */
-function rollOf(d, R, theta) {
-    if (R > 1e-3 && d < R * theta)
-        return [R * Math.sin(d / R), R * (1 - Math.cos(d / R))];
-    const rest = d - R * theta;
-    return [R * Math.sin(theta) + rest * Math.cos(theta), R * (1 - Math.cos(theta)) + rest * Math.sin(theta)];
-}
-/** How far through its turn a leaf is: the point taken, from where it
- *  was to its mirror image across the spine. */
-export function progressFrom(G, P) {
-    return Math.min(1, Math.max(0, (G.u - P.u) / (2 * G.u)));
-}
-/** The hand can carry the point taken no farther from the spine's ends
- *  than the paper reaches. */
-function reach(G, P, H) {
-    let { u, v } = P;
-    for (let i = 0; i < 4; i++) {
-        for (const S of [-H / 2, H / 2]) {
-            const r = Math.hypot(G.u, G.v - S);
-            const d = Math.hypot(u, v - S);
-            if (d > r) {
-                u *= r / d;
-                v = S + ((v - S) * r) / d;
-            }
-        }
-    }
-    return { u, v };
-}
-/**
- * Lays a leaf's mesh out. The curl is worked out on the flat page (u from
- * the spine), then wrapped onto the book: the part on the right follows
- * the right stack's top (into the gutter and out), the part carried over
- * the spine the left one's. A stiff leaf (`rigidity`) turns more as a
- * plate on its hinge: a board does not bend at all.
- */
-export function layLeaf(geometry, fold, forward, W, H, lift, book, rigidity, q, flutter = 0, time = 0, board) {
-    const pos = geometry.attributes.position;
-    const sx = forward ? 1 : -1;
-    const [xr, zr] = along(book.right, W);
-    const [xl, zl] = along(book.left, W);
-    const zr0 = along(book.right, 0)[1];
-    const zl0 = along(book.left, 0)[1];
-    const qa = forward ? q : 1 - q;
-    let hinge;
-    let phi;
-    let r;
-    let offset = 0;
-    if (board) {
-        // A board (a cover): a rigid slab `thick` deep, turning on the joint at
-        // the top of the spine. It leaves the block it lay on (its chord, from
-        // the spine to the fore-edge) and lands on the other side's, however
-        // that lies: flat on an open book, hanging down to the desk from a
-        // spine still standing. As it comes down to the lower side the joint
-        // comes down the spine with it (the cloth flexes), so it lands instead
-        // of dropping. The pivot is its middle plane: it lies with its inner
-        // face on the block under it and lands with its outer face on the
-        // other, and `face` sets which of its faces this mesh draws.
-        const descend = zl0 < zr0 ? smooth(0.4, 1, qa) : 1 - smooth(0.4, 1, 1 - qa);
-        hinge = zr0 + (zl0 - zr0) * descend + board.thick / 2;
-        const a0 = Math.atan2(zr - zr0, xr);
-        const a1 = Math.PI - Math.atan2(zl - zl0, xl);
-        // The hand holds the point it took over the desk: a rigid plate turned
-        // by φ brings it to u·cos φ, so the board stands where the hand has
-        // carried that point (q = (1 − cos)/2), not on an eased curve that laid
-        // it level in the air while the hand was still over the slope.
-        phi = a0 + ((a1 - a0) * Math.acos(Math.min(1, Math.max(-1, 1 - 2 * qa)))) / Math.PI;
-        r = 1;
-        offset = (board.face * board.thick) / 2;
-    }
-    else {
-        // A stiff leaf rests on its stack's fore-edge and swings over the gutter.
-        r = rigidity * smooth(0, 0.06, q) * smooth(0, 0.06, 1 - q);
-        hinge = along(book.right, 0)[1];
-        const a0 = Math.atan2(zr - hinge, xr);
-        const a1 = Math.PI - Math.atan2(zl - hinge, xl);
-        phi = a0 + (a1 - a0) * qa;
-    }
-    // How far a turning leaf stands off the pages: none at rest or for a
-    // corner barely lifted, a few degrees through the middle of the turn.
-    const inAir = smooth(0.02, 0.22, q) * smooth(0.02, 0.22, 1 - q);
-    const lean = LEAN * inAir;
-    // Each side's chord, from the spine to its fore-edge: a side hanging
-    // from a standing spine slopes down to the desk, and a leaf leaning off
-    // it leans off that slope, not off a level plane over it.
-    const chordR = (zr - zr0) / (xr || 1);
-    const chordL = (zl - zl0) / (xl || 1);
-    // The plane a leaf lifts off along, by side: the chord turned up by the
-    // lean. A leaf keeps its width along it (stepping the chord's rise per
-    // unit across, on a side sloping to the desk, stretched it by a tenth
-    // and more, #495).
-    const tiltR = Math.atan(chordR) + lean;
-    const tiltL = Math.atan(chordL) + lean;
-    // Onto the book. At rest (and as it lands) the leaf lies on the open
-    // book's surface, into the gutter and out. In the air it is lifted off
-    // at the spine: its own plane rises from the gutter's floor at a small
-    // angle, and it touches the pages only where they stand higher (the
-    // gutter's walls), joined smoothly. `z`: how far over that it stands.
-    const onBook = (s, z) => {
-        const [rx, rz] = surfaceAt(book, s);
-        let px = rx;
-        let pz = rz + z + lift;
-        if (inAir > 0) {
-            const tilt = s >= 0 ? tiltR : tiltL;
-            const fx = (s >= 0 ? 1 : -1) * Math.abs(s) * Math.cos(tilt);
-            const plane = (s >= 0 ? zr0 : zl0) + Math.abs(s) * Math.sin(tilt) + z + lift;
-            const under = surfaceAt(book, fx)[1] + lift + 0.6;
-            const flying = smoothMax(plane, under, 0.006 * W);
-            px += (fx - px) * inAir;
-            pz += (flying - pz) * inAir;
-        }
-        return [px, pz];
-    };
-    // Thin paper ripples in the air, more towards its free edge. Never
-    // down into the pages under it: the ripple dies away where the leaf
-    // lies close over them (it stays at least `lift` above them), or a
-    // leaf held low over its stack dipped into the page under it, whose
-    // print then showed through (#447).
-    const ripple = (u, v, px, pz) => {
-        const amp = flutter * W * (u / W) * (u / W);
-        if (flutter <= 0 || amp <= 1e-6)
-            return 0;
-        const clear = pz - surfaceAt(book, px)[1] - lift;
-        return amp * smooth(0, 2 * amp, clear) * Math.sin(2 * Math.PI * (time / 520) - (3 * u) / W + (2 * v) / H);
-    };
-    // Where the leaf's paper lies unfolded, column by column (before it
-    // ripples): [out from the spine, u, height].
-    const clearing = BLOCK_GAP * smooth(0, 0.06, q) * smooth(0, 0.06, 1 - q);
-    const own = [];
-    if (fold) {
-        for (let ix = 0; ix <= NX; ix++) {
-            const u = column(ix / NX) * W;
-            let [ox, oz] = onBook(sx * u, 0);
-            if (r > 0) {
-                ox += (u * Math.cos(phi) - offset * Math.sin(phi) - ox) * r;
-                oz += (hinge + lift + u * Math.sin(phi) + offset * Math.cos(phi) - oz) * r;
-            }
-            own.push([sx * ox, u, oz]);
-        }
-    }
-    for (let iy = 0; iy <= NY; iy++) {
-        const v = (0.5 - iy / NY) * H;
-        for (let ix = 0; ix <= NX; ix++) {
-            const u = column(ix / NX) * W;
-            let x = u;
-            let y = v;
-            let z = 0;
-            let d = 0;
-            let dd = 0;
-            if (fold) {
-                const { F, n } = fold;
-                d = (u - F.u) * n.u + (v - F.v) * n.v;
-                if (d > 0) {
-                    // Round the roll, then straight on at the fold's angle.
-                    [dd, z] = rollOf(d, fold.R, fold.theta);
-                    y = v - n.v * (d - dd);
-                    x = u - n.u * (d - dd);
-                }
-            }
-            let [px, pz] = onBook(sx * x, z);
-            if (fold && d > 0) {
-                // Paper up in the air is not pressed onto the pages under it: wrapped
-                // onto them it dipped into the gutter and was squeezed across it (a
-                // crease where the curl passed over the spine). It goes on from the
-                // foot of its fold, level, as the fold has it, and only comes down
-                // onto the pages as it does (lying back over itself, landing).
-                const [fx, fz] = onBook(sx * (u - fold.n.u * d), 0);
-                const w = smooth(0, 0.05 * W, z);
-                px += (fx + sx * fold.n.u * dd - px) * w;
-                pz += (fz + z - pz) * w;
-            }
-            if (r > 0) {
-                px += (u * Math.cos(phi) - offset * Math.sin(phi) - px) * r;
-                y += (v - y) * r;
-                pz += (hinge + lift + u * Math.sin(phi) + offset * Math.cos(phi) - pz) * r;
-            }
-            pz += ripple(u, v, px, pz);
-            // Never through the leaf's own paper not yet folded, as it ripples
-            // too: carried level from a fold low on a side sloping up to the
-            // spine, the paper folded back over it ran under it, crossing it.
-            if (fold && d > 0) {
-                const at = sx * px;
-                // (A row past the head and foot too: a triangle reaching past them
-                // from paper kept over sagged through.)
-                if (at > own[0][0] && at < own[NX][0] && Math.abs(y) <= H / 2 + (1.5 * H) / NY) {
-                    let lo = 0;
-                    let hi = NX;
-                    while (hi - lo > 1) {
-                        const mid = (lo + hi) >> 1;
-                        if (own[mid][0] <= at)
-                            lo = mid;
-                        else
-                            hi = mid;
-                    }
-                    const f = (at - own[lo][0]) / (own[hi][0] - own[lo][0] || 1);
-                    const ou = own[lo][1] + (own[hi][1] - own[lo][1]) * f;
-                    if ((ou - fold.F.u) * fold.n.u + (y - fold.F.v) * fold.n.v < 0) {
-                        const oz = own[lo][2] + (own[hi][2] - own[lo][2]) * f;
-                        pz = Math.max(pz, oz + ripple(ou, y, px, oz) + OWN_GAP);
-                    }
-                }
-            }
-            // Never into the book: over a block (and past its head or foot) a
-            // leaf stands at least just over its top. A fold's flap is carried
-            // level from the foot of its fold, and on a thin side hanging from
-            // the spine that foot lies low: the flap went through the tall block
-            // on the other side (#489).
-            // In the air a little higher still (until it lands): half a pixel
-            // over the block is hardly any depth at the view's distance, and a
-            // leaf lying over a tall block's top drew through its page in teeth.
-            if (!board && Math.abs(px) < (px >= 0 ? xr : xl))
-                pz = Math.max(pz, topAt(px >= 0 ? book.right : book.left, Math.abs(px)) + Math.min(lift, 0.5) + clearing);
-            pos.setXYZ(iy * (NX + 1) + ix, px, y, pz);
-        }
-    }
-    pos.needsUpdate = true;
-    geometry.computeVertexNormals();
-    return { phi, pivot: hinge + lift };
-}
-/** Frees a leaf's mesh and a board's parts. */
-function disposeLeaf(mesh) {
-    const parts = mesh.userData.board;
-    if (parts) {
-        parts.back.geometry.dispose();
-        parts.slab.geometry.dispose();
-        parts.slab.material.dispose();
-    }
-    mesh.userData.caster?.geometry.dispose();
-    mesh.geometry.dispose();
-    mesh.material.dispose();
-}
-/**
- * The plane an open page lies in past the gutter's shoulder (world,
- * normal up), its side running out from the spine along world x as
- * `out` (±1): level on a block lying on the desk, sloping down to it on
- * the thin side of a thick book, which hangs from the top of the spine.
- * A gloss page mirrors the leaves in the air in it (#483).
- */
-export function pagePlane(p, W, out) {
-    const [x0, z0] = along(p, W * 0.55);
-    const [x1, z1] = along(p, W);
-    const dx = out * (x1 - x0);
-    const dz = z1 - z0;
-    const normal = new Vector3(-dz * Math.sign(dx || 1), 0, Math.abs(dx)).normalize();
-    return new Plane().setFromNormalAndCoplanarPoint(normal, new Vector3(out * x0, 0, z0));
-}
+import { WebGLRenderer, Scene, PerspectiveCamera, Mesh, PlaneGeometry, MeshStandardMaterial, Group, MeshPhysicalMaterial, Texture, BoxGeometry, DirectionalLight, PMREMGenerator, OrthographicCamera, WebGLRenderTarget, Vector2, TextureLoader, Raycaster, SRGBColorSpace, NeutralToneMapping, HalfFloatType, PCFShadowMap, LinearFilter, BufferAttribute, ShadowMaterial, Color, Vector3, LinearMipmapLinearFilter, Plane, DepthTexture, Matrix4, Vector4 } from 'three';
+import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer.js';
+import { OutputPass } from 'three/examples/jsm/postprocessing/OutputPass.js';
+import { RenderPass } from 'three/examples/jsm/postprocessing/RenderPass.js';
+import { SMAAPass } from 'three/examples/jsm/postprocessing/SMAAPass.js';
+import { resolveFolioConfig } from 'postext';
+import { BINDINGS, profiles, gutterOcclusion, along, stackGeometry } from './bookGeometry.js';
+import { environment } from './environments.js';
+import { paperSpec, pagePaper } from './paper.js';
+import { loadDeskMaps } from './deskTextures.js';
+import { VideoAtlas, ATLAS_MAX, MAX_PAGE_VIDEOS } from './videoAtlas.js';
+import { cachedDesk, cachedRelief } from './procedural.js';
+import { Loupe } from './loupe.js';
+import { FOV, NX_OPEN, NX, NY, BLOCK_PAGES, DURATION, BLOCK_DURATION, GAP, GRIP } from './pageFlip/constants.js';
+import { spreadColumns, column, MAX_PITCH, disposeLeaf, progressFrom, reach, foldOf, layLeaf, pagePlane } from './pageFlip/leaf.js';
+import { edgeMaterial, pageMaterial, withStockForExtent, edgeUniforms, edgeColorOf, ease, easeOut, smooth, behindUniforms } from './pageFlip/materials.js';
+import { occluded, casterMaterial, casterGeometry, occlusionUniforms, syncCaster } from './pageFlip/occlusion.js';
+export { BLOCK_PAGES } from './pageFlip/constants.js';
+export { withStockForExtent } from './pageFlip/materials.js';
+export { foldOf, progressFrom, layLeaf, pagePlane } from './pageFlip/leaf.js';
 /**
  * Turns the pages of the viewer's DOM spread in a 3D scene: the book lies
  * open on a desk, seen from in front and above (tilted by `folio.tilt`),