@zinejs/core 0.1.0 → 0.3.0

package/dist/renderer/types.d.ts

@@ -1,4 +1,5 @@
 import type { Spread } from '../engine/spread';
+import type { CurlType, CurlAnchor } from '../geometry/curls/types';
 /** A decoded, ready-to-paint raster for one page (produced by a content source). */
 export type PageContent = ImageBitmap | HTMLCanvasElement;
 /** Resolved content for the two halves of a spread; null = blank side. */
@@ -10,6 +11,10 @@ export type FlipDirection = 'forward' | 'backward';
 export interface RenderOptions {
     /** Render a lone page filling the container (single-page mode), not a half panel. */
     fill?: boolean;
+    /** Which page-curl model the WebGL2 renderer bends the leaf with (ignored by CSS). */
+    curl?: CurlType;
+    /** Corner the fold originates from for anchored curls; y in [0,1] (where the reader tapped). */
+    anchor?: CurlAnchor;
 }
 /** Layout metrics the engine needs for geometry and mode decisions. */
 export interface LayoutMetrics {
@@ -17,6 +22,23 @@ export interface LayoutMetrics {
     containerHeight: number;
     pageWidth: number;
     pageHeight: number;
+    /** The letterboxed book area (aspect-fitted, centered) in container px — a stable 2-page
+     *  (or 1-page in fill) region used for aspect sizing. Omit to fall back to the full container. */
+    book?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Where the current spread is actually painted, in container px — equal to `book` for a
+     *  full spread, but the centered half for a lone page (cover / book front-back). This is the
+     *  region the engine hit-tests against so taps track the visible page. Omit to fall back. */
+    content?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
 }
 /**
  * The contract every renderer implements (CSS baseline, WebGL2/GPU). The engine

package/dist/renderer/webglRenderer.d.ts

@@ -1,10 +1,11 @@
 import type { Spread } from '../engine/spread';
 import type { FlipDirection, LayoutMetrics, Renderer, RenderOptions, SpreadContent } from './types';
 /**
- * GPU renderer (WebGL2, hand-written, no third-party library). The turning leaf is
- * a grid mesh bent around a cylinder (driven by the shared flipProgressToPose), the
- * static pages are flat textured quads underneath. Restores its GL state in place on
- * context loss; if that fails it signals `onFatal` so the engine can fall back to CSS.
+ * GPU renderer (WebGL2, hand-written). The turning leaf is a dense grid deformed on
+ * the CPU by the selected curl model (see geometry/curls) and
+ * uploaded each frame, lit from real normals; the static pages are flat quads with a
+ * gutter shadow. Restores
+ * GL state on context loss; signals onFatal (→ CSS fallback) when unrecoverable.
  */
 export declare class WebglRenderer implements Renderer {
     #private;
@@ -13,7 +14,7 @@ export declare class WebglRenderer implements Renderer {
     onFatal(handler: () => void): void;
     renderSpread(_spread: Spread, content: SpreadContent, options?: RenderOptions): void;
     beginFlip(from: SpreadContent, to: SpreadContent, direction: FlipDirection, options?: RenderOptions): void;
-    setFlipProgress(t: number, direction: FlipDirection): void;
+    setFlipProgress(t: number, _direction: FlipDirection): void;
     setViewTransform(scale: number, x: number, y: number): void;
     measure(): LayoutMetrics;
 }

package/dist/source/compose.d.ts

@@ -0,0 +1,16 @@
+import type { Source } from './types';
+export interface CompositionOptions {
+    /** Image URL prepended as a lone front cover (adds a page). */
+    frontCover?: string | null;
+    /** Image URL appended as a lone back cover (adds a page). */
+    backCover?: string | null;
+    /** Replace source pages with image URLs, keyed by 0-based source index (negative = from the end). */
+    pages?: Record<number, string> | null;
+}
+/**
+ * Wrap `base` so image covers/replacements sit alongside it, or return `base`
+ * unchanged when nothing is requested. Covers ADD pages (front prepended, back
+ * appended); `pages` REPLACE existing source pages. `pages` indexes the base's own
+ * pages, so it is unaffected by an added cover.
+ */
+export declare function composeSource(base: Source, options: CompositionOptions): Source;

package/dist/source/types.d.ts

@@ -18,4 +18,10 @@ export interface Source {
     prefetch(indices: number[]): void;
     /** Release any decoded resources. */
     destroy(): void;
+    /**
+     * Optional: register a handler called when a page's content has been upgraded
+     * (e.g. a progressive PDF render swapping low-res for crisp), so the engine can
+     * re-render that page if it's on screen.
+     */
+    onPageUpdate?(handler: (index: number) => void): void;
 }

package/dist/types-D-rEO00p.js

@@ -0,0 +1,12 @@
+//#region src/geometry/curls/types.ts
+var e = [
+	"roll",
+	"cone",
+	"leaf",
+	"flick",
+	"simple"
+], t = "cone";
+//#endregion
+export { t as n, e as t };
+
+//# sourceMappingURL=types-D-rEO00p.js.map

package/dist/types-D-rEO00p.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-D-rEO00p.js","names":[],"sources":["../src/geometry/curls/types.ts"],"sourcesContent":["/**\n * Curl type identifiers and the deform contract. Kept free of the deform\n * implementations so the engine (and CSS-only builds) can reference the union and the\n * validation list without pulling the WebGL-only curl math into the eager bundle.\n */\nimport type { PageMesh } from './mesh';\n\n/** Where a corner-anchored curl folds from: y in [0,1], 0 = top edge, 1 = bottom edge. */\nexport interface CurlAnchor {\n  y: number;\n  /**\n   * Full-width lone page (single-page mode). The leaf hinges at the container edge and\n   * has no facing half to land on — deforms may soften and delay the flop so the curl\n   * reads naturally before the renderer dissolves the sheet.\n   */\n  fill?: boolean;\n}\n\nexport type CurlDeform = (mesh: PageMesh, W: number, H: number, t: number, anchor: CurlAnchor) => void;\n\nexport interface CurlModel {\n  readonly deform: CurlDeform;\n  /** True when the fold originates at a corner (`anchor.y`) rather than the whole edge. */\n  readonly anchored: boolean;\n}\n\nexport type CurlType = 'roll' | 'cone' | 'leaf' | 'flick' | 'simple';\n\nexport const CURL_TYPES: CurlType[] = ['roll', 'cone', 'leaf', 'flick', 'simple'];\n\nexport const DEFAULT_CURL: CurlType = 'cone';\n"],"mappings":";AA4BA,IAAa,IAAyB;CAAC;CAAQ;CAAQ;CAAQ;CAAS;AAAQ,GAEnE,IAAyB"}

package/dist/webglRenderer-Bg6VF4CW.js

@@ -0,0 +1,558 @@
+import { n as e } from "./types-D-rEO00p.js";
+//#region src/geometry/curls/mesh.ts
+function t(e, t) {
+	let n = e + 1, r = t + 1, i = n * r, a = new Float32Array(i * 2);
+	for (let i = 0; i < r; i++) for (let r = 0; r < n; r++) {
+		let o = i * n + r;
+		a[o * 2] = r / e, a[o * 2 + 1] = i / t;
+	}
+	return {
+		cols: e,
+		rows: t,
+		uvs: a,
+		positions: new Float32Array(i * 3),
+		normals: new Float32Array(i * 3)
+	};
+}
+function n(e) {
+	let t = e.cols + 1, n = e.rows + 1, r = e.positions, i = e.normals;
+	for (let e = 0; e < n; e++) for (let a = 0; a < t; a++) {
+		let o = a > 0 ? a - 1 : a, s = a < t - 1 ? a + 1 : a, c = e > 0 ? e - 1 : e, l = e < n - 1 ? e + 1 : e, u = (e * t + s) * 3, d = (e * t + o) * 3, f = (l * t + a) * 3, p = (c * t + a) * 3, m = r[u] - r[d], h = r[u + 1] - r[d + 1], g = r[u + 2] - r[d + 2], _ = r[f] - r[p], v = r[f + 1] - r[p + 1], y = r[f + 2] - r[p + 2], b = h * y - g * v, x = g * _ - m * y, S = m * v - h * _, C = Math.hypot(b, x, S) || 1;
+		b /= C, x /= C, S /= C;
+		let w = (e * t + a) * 3;
+		i[w] = b, i[w + 1] = x, i[w + 2] = S;
+	}
+}
+//#endregion
+//#region src/geometry/curls/roll.ts
+function r(e, t, r, i) {
+	let a = e.cols + 1, o = e.rows + 1, s = e.positions, c = Math.max(1e-6, i < .5 ? i * 2 * Math.PI : (1 - (i - .5) * 2) * Math.PI), l = t / c, u = i < .5 ? 0 : -(i - .5) * 2 * Math.PI, d = Math.cos(u), f = Math.sin(u);
+	for (let t = 0; t < a; t++) {
+		let n = t / e.cols * c, i = Math.sin(n) * l, u = (1 - Math.cos(n)) * l, p = i * d + u * f, m = -i * f + u * d;
+		for (let n = 0; n < o; n++) {
+			let i = (n * a + t) * 3;
+			s[i] = p, s[i + 1] = n / e.rows * r, s[i + 2] = m;
+		}
+	}
+	n(e);
+}
+//#endregion
+//#region src/geometry/curls/cone.ts
+var i = 30 * Math.PI / 180, a = 44 * Math.PI / 180, o = 1.35, s = .7, c = 1.85, l = 1.15, u = .42, d = 1.08;
+function f(e, t, r, f, p) {
+	let m = e.cols + 1, h = e.rows + 1, g = e.positions, _ = !!p.fill, v = Math.sin(Math.PI * f) ** .85, y = _ ? a : i, b = Math.PI / 2 - v * (Math.PI / 2 - y), x = Math.sin(b), S = Math.cos(b), C = 1 / Math.max(x, 1e-6), w = _ ? c : o, T = r * (w + ((_ ? l : s) - w) * v), E = (p.y - .5) * 2, D = E >= 0, O = Math.min(1, Math.abs(E) / u), k = 1 - O, A = D ? r + T : -T, j = Math.hypot(t, .5 * r - A), M = Math.max(j * x, t / Math.PI), N = _ ? f ** +d : f, P = -Math.PI * N, F = Math.cos(P), I = Math.sin(P);
+	if (v < 1e-4) {
+		for (let n = 0; n < h; n++) {
+			let i = n / e.rows * r;
+			for (let r = 0; r < m; r++) {
+				let a = r / e.cols * t, o = (n * m + r) * 3;
+				g[o] = a * F, g[o + 1] = i, g[o + 2] = -a * I;
+			}
+		}
+		n(e);
+		return;
+	}
+	for (let n = 0; n < h; n++) {
+		let i = n / e.rows * r;
+		for (let a = 0; a < m; a++) {
+			let o = a / e.cols * t, s = o, c = i, l = 0;
+			if (O > 1e-5) {
+				let e = D ? r - i : i, t = -T, n = Math.hypot(o, e - t);
+				if (n > 1e-8) {
+					let e = n * x, i = Math.asin(Math.min(1, Math.max(0, o / n))) * C, a = 1 - Math.cos(i), u = n + t - e * a * x;
+					s = e * Math.sin(i), c = D ? r - u : u, l = e * a * S;
+				}
+			}
+			let u = s, d = c, f = l;
+			if (k > 1e-5) {
+				let e = o / M, t = M * Math.sin(e), n = M * (1 - Math.cos(e));
+				u = O * s + k * t, d = O * c + k * i, f = O * l + k * n;
+			}
+			let p = (n * m + a) * 3;
+			g[p] = u * F + f * I, g[p + 1] = d, g[p + 2] = -u * I + f * F;
+		}
+	}
+	n(e);
+}
+//#endregion
+//#region src/geometry/curls/leaf.ts
+var p = .34, m = 11 * Math.PI / 180, h = 128;
+function g() {
+	let e = /* @__PURE__ */ new Float64Array(129), t = /* @__PURE__ */ new Float64Array(129), n = 1 / h, r = (e) => Math.PI * e - .5 * Math.sin(2 * Math.PI * e);
+	for (let i = 1; i <= h; i++) {
+		let a = r((i - 1) * n), o = r(i * n);
+		e[i] = e[i - 1] + .5 * (Math.cos(a) + Math.cos(o)) * n, t[i] = t[i - 1] + .5 * (Math.sin(a) + Math.sin(o)) * n;
+	}
+	return e[h] = 0, {
+		x: e,
+		z: t
+	};
+}
+var _ = g(), v = _.z[h];
+function y(e) {
+	let t = Math.max(0, Math.min(1, e)) * h, n = Math.min(h - 1, Math.floor(t)), r = t - n;
+	return [_.x[n] + (_.x[n + 1] - _.x[n]) * r, _.z[n] + (_.z[n + 1] - _.z[n]) * r];
+}
+function b(e, t, r, i, a) {
+	let o = e.cols + 1, s = e.rows + 1, c = e.positions;
+	if (i <= 1e-7 || i >= .9999999) {
+		let a = i < .5 ? 1 : -1;
+		for (let n = 0; n < s; n++) {
+			let i = n / e.rows * r;
+			for (let r = 0; r < o; r++) {
+				let s = (n * o + r) * 3;
+				c[s] = a * (r / e.cols) * t, c[s + 1] = i, c[s + 2] = 0;
+			}
+		}
+		n(e);
+		return;
+	}
+	let l = Math.sin(Math.PI * i) ** .72, u = Math.max(1e-6, t * p * l), d = Math.max(-1, Math.min(1, (a.y - .5) * 2)) * m * Math.sin(Math.PI * i) ** 1.15, f = Math.cos(d), h = Math.sin(d), g = -h, _ = f, b = Math.abs(h) * r * .5, x = t + b / f, S = x + (-(u + b) / f - x) * i, C = r * .5;
+	for (let n = 0; n < s; n++) {
+		let i = n / e.rows * r;
+		for (let r = 0; r < o; r++) {
+			let a = r / e.cols * t, s = a - S, l = i - C, d = s * f + l * h, p = s * g + l * _, m = (n * o + r) * 3;
+			if (d <= 0) {
+				c[m] = a, c[m + 1] = i, c[m + 2] = 0;
+				continue;
+			}
+			let b, x;
+			if (d < u) {
+				let [e, t] = y(d / u);
+				b = u * e, x = u * t;
+			} else b = -(d - u), x = u * v;
+			c[m] = S + g * p + f * b, c[m + 1] = C + _ * p + h * b, c[m + 2] = x;
+		}
+	}
+	n(e);
+}
+//#endregion
+//#region src/geometry/curls/flick.ts
+var x = .45;
+function S(e, t, r, i, a) {
+	let o = e.cols + 1, s = e.rows + 1, c = e.cols, l = e.positions, u = t / c, d = Math.PI * i, f = -.52 * Math.sin(2 * Math.PI * i);
+	for (let t = 0; t < s; t++) {
+		let n = t / e.rows, i = f * (1 + x * Math.abs(n - a.y)), s = n * r, p = 0, m = 0, h = Math.cos(d), g = Math.sin(d);
+		l[t * o * 3] = 0, l[t * o * 3 + 1] = s, l[t * o * 3 + 2] = 0;
+		for (let e = 1; e < o; e++) {
+			let n = e / c, r = d + i * n * n, a = Math.cos(r), f = Math.sin(r);
+			p += .5 * (h + a) * u, m += .5 * (g + f) * u, h = a, g = f;
+			let _ = (t * o + e) * 3;
+			l[_] = p, l[_ + 1] = s, l[_ + 2] = m;
+		}
+	}
+	n(e);
+}
+//#endregion
+//#region src/geometry/curls/simple.ts
+function C(e, t, r, i) {
+	let a = e.cols + 1, o = e.rows + 1, s = e.positions, c = i * Math.PI, l = Math.cos(c), u = Math.sin(c);
+	for (let n = 0; n < a; n++) {
+		let i = n / e.cols * t, c = i * l, d = i * u;
+		for (let t = 0; t < o; t++) {
+			let i = (t * a + n) * 3;
+			s[i] = c, s[i + 1] = t / e.rows * r, s[i + 2] = d;
+		}
+	}
+	n(e);
+}
+//#endregion
+//#region src/geometry/curls/index.ts
+var w = {
+	roll: {
+		deform: r,
+		anchored: !1
+	},
+	cone: {
+		deform: f,
+		anchored: !0
+	},
+	leaf: {
+		deform: b,
+		anchored: !0
+	},
+	flick: {
+		deform: S,
+		anchored: !0
+	},
+	simple: {
+		deform: C,
+		anchored: !1
+	}
+};
+//#endregion
+//#region src/renderer/gl/context.ts
+function T(e) {
+	let t = e.getContext("webgl2", {
+		alpha: !0,
+		premultipliedAlpha: !0,
+		antialias: !0,
+		depth: !1,
+		stencil: !1,
+		preserveDrawingBuffer: !0
+	});
+	if (t === null) throw Error("WebglRenderer: could not create a WebGL2 context.");
+	return t;
+}
+//#endregion
+//#region src/renderer/gl/program.ts
+function E(e, t, n) {
+	let r = e.createProgram();
+	if (r === null) throw Error("WebglRenderer: could not create a program.");
+	let i = D(e, e.VERTEX_SHADER, t), a = D(e, e.FRAGMENT_SHADER, n);
+	if (e.attachShader(r, i), e.attachShader(r, a), e.linkProgram(r), e.deleteShader(i), e.deleteShader(a), !e.getProgramParameter(r, e.LINK_STATUS)) {
+		let t = e.getProgramInfoLog(r);
+		throw e.deleteProgram(r), Error(`WebglRenderer: program link failed: ${t ?? "unknown error"}`);
+	}
+	return r;
+}
+function D(e, t, n) {
+	let r = e.createShader(t);
+	if (r === null) throw Error("WebglRenderer: could not create a shader.");
+	if (e.shaderSource(r, n), e.compileShader(r), !e.getShaderParameter(r, e.COMPILE_STATUS)) {
+		let t = e.getShaderInfoLog(r);
+		throw e.deleteShader(r), Error(`WebglRenderer: shader compile failed: ${t ?? "unknown error"}`);
+	}
+	return r;
+}
+//#endregion
+//#region src/renderer/gl/texture.ts
+function O(e) {
+	let t = e.createTexture();
+	if (t === null) throw Error("WebglRenderer: could not create a texture.");
+	return e.bindTexture(e.TEXTURE_2D, t), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_S, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_WRAP_T, e.CLAMP_TO_EDGE), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MIN_FILTER, e.LINEAR), e.texParameteri(e.TEXTURE_2D, e.TEXTURE_MAG_FILTER, e.LINEAR), t;
+}
+function k(e, t, n) {
+	e.bindTexture(e.TEXTURE_2D, t), e.pixelStorei(e.UNPACK_FLIP_Y_WEBGL, !1), e.pixelStorei(e.UNPACK_PREMULTIPLY_ALPHA_WEBGL, !0), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, e.RGBA, e.UNSIGNED_BYTE, n);
+}
+//#endregion
+//#region src/renderer/webglRenderer.ts
+var A = "#version 300 es\nin vec2 aUnit;\nuniform vec2 uViewport;\nuniform vec4 uRect;\nuniform vec3 uView;\nout vec2 vUv;\nvoid main() {\n  vec2 px = uRect.xy + aUnit * uRect.zw;\n  px = px * uView.x + uView.yz;\n  vec2 clip = px / uViewport * 2.0 - 1.0;\n  gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n  vUv = aUnit;\n}", j = "#version 300 es\nprecision mediump float;\nin vec2 vUv;\nuniform sampler2D uTex;\nuniform float uGutterSide; // +1 = spine at right edge, -1 = at left edge, 0 = none\nout vec4 outColor;\nvoid main() {\n  vec4 c = texture(uTex, vUv);\n  if (uGutterSide != 0.0) {\n    float d = uGutterSide > 0.0 ? (1.0 - vUv.x) : vUv.x;\n    c.rgb *= mix(0.72, 1.0, smoothstep(0.0, 0.10, d));\n  }\n  outColor = c;\n}", M = "#version 300 es\nin vec3 aPos;    // leaf-local device px: x = bent offset from spine, y 0..H, z depth\nin vec3 aNormal;\nin vec2 aUv;\nuniform vec2 uViewport;\nuniform vec3 uView;   // scale, tx, ty\nuniform float uOriginX; // spine x in device px\nuniform float uDir;     // +1 leaf to the right of spine, -1 to the left\nuniform float uLeafW;   // leaf width in device px (perspective scale)\nout vec2 vUv;\nout float vFacing;\nout float vU;\nvoid main() {\n  float bookX = uOriginX + uDir * aPos.x;\n  float bookY = aPos.y;\n  float Z = aPos.z;\n  // Eye distance, in leaf widths. Keeps the perspective resolution-independent. 5.3 puts the\n  // roll's deepest point ~14% larger than flat; stronger than that (a nearer eye) balloons the\n  // turning sheet and reads more like a fisheye than a page lifting.\n  float D = uLeafW * 5.3;\n  float persp = D / max(D - Z, 1.0);\n  float cx = uViewport.x * 0.5;\n  float cy = uViewport.y * 0.5;\n  float px = cx + (bookX - cx) * persp;\n  float py = cy + (bookY - cy) * min(persp, 1.0); // Y only shrinks (top-safe)\n  vec2 p = vec2(px, py) * uView.x + uView.yz;\n  vec2 clip = p / uViewport * 2.0 - 1.0;\n  gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n  vUv = aUv;\n  vFacing = aNormal.z;\n  vU = aUv.x;\n}", N = "#version 300 es\nprecision mediump float;\nin vec2 vUv;\nin float vFacing;\nin float vU;\nuniform sampler2D uFront;\nuniform sampler2D uBack;\nuniform highp float uDir;\nuniform float uGloss; // 0 disables the specular highlight (e.g. the flat 'simple' curl)\nuniform float uAlpha; // leaf opacity; a lone page dissolves into the page landing beneath it\nout vec4 outColor;\nvoid main() {\n  // The turn mesh carries its own facing in the normal; the front points at the viewer\n  // (normal.z > 0) until the leaf passes vertical, for both flip directions. u->x still\n  // flips with uDir so a left-hand leaf reads spine-inward.\n  bool showFront = vFacing > 0.0;\n  float fx = uDir > 0.0 ? vUv.x : 1.0 - vUv.x;\n  vec4 c = showFront ? texture(uFront, vec2(fx, vUv.y)) : texture(uBack, vec2(1.0 - fx, vUv.y));\n\n  // Fold shading: the sheet darkens sharply where it curves away from the viewer, so the\n  // rolled edge reads as a deep crease with a soft highlight riding the ridge.\n  float diff = clamp(abs(vFacing), 0.0, 1.0);\n  float lit = mix(0.42, 1.0, diff);\n  lit *= mix(0.7, 1.0, smoothstep(0.0, 0.12, vU)); // spine crease matches the gutter shadow\n\n  // Glossy specular: brightest where the surface tilts ~30 deg from facing the viewer,\n  // so a thin glossy highlight rides across the sheet as it rolls.\n  float spec = pow(max(cos(acos(diff) - 0.52), 0.0), 220.0) * 0.22 * uGloss;\n\n  c.rgb = clamp(c.rgb * lit + spec, 0.0, 1.0);\n  // Premultiplied alpha (blendFunc ONE, ONE_MINUS_SRC_ALPHA): scale colour as well as alpha,\n  // or fading would brighten the sheet additively instead of dissolving it.\n  outColor = vec4(c.rgb * uAlpha, c.a * uAlpha);\n}", P = 28, F = 36, I = .7, L = .8, R = 4e3, z = 256 * 1024 * 1024;
+function B(e) {
+	return e.left === null == (e.right === null) ? 0 : e.right === null ? 1 : -1;
+}
+var V = class {
+	#e = null;
+	#t = null;
+	#n = null;
+	#r = null;
+	#i = null;
+	#a = null;
+	#o = null;
+	#s = null;
+	#c = null;
+	#l = 0;
+	#u = t(P, F);
+	#d = /* @__PURE__ */ new Map();
+	#f = 0;
+	#p = null;
+	#m = {};
+	#h = {};
+	#g = {
+		scale: 1,
+		tx: 0,
+		ty: 0
+	};
+	#_ = 1;
+	#v = null;
+	#y = !1;
+	#b = null;
+	#x = 0;
+	#S = e;
+	#C = { y: .5 };
+	#w = 0;
+	#T = 0;
+	#E = 0;
+	#D = 0;
+	#O = 0;
+	#k = 0;
+	#A = !1;
+	#j = !1;
+	#M = null;
+	#N = null;
+	mount(e) {
+		this.#e = e;
+		let t = e.ownerDocument, n = t.createElement("canvas");
+		return n.style.cssText = "display:block;width:100%;height:100%;", e.append(n), this.#t = n, n.addEventListener("webglcontextlost", this.#L), n.addEventListener("webglcontextrestored", this.#R), t.addEventListener("visibilitychange", this.#z), this.#n = T(n), this.#H(), Promise.resolve();
+	}
+	destroy() {
+		this.#V();
+		let e = this.#t;
+		e !== null && (e.removeEventListener("webglcontextlost", this.#L), e.removeEventListener("webglcontextrestored", this.#R), e.ownerDocument.removeEventListener("visibilitychange", this.#z));
+		let t = this.#n;
+		if (t !== null) {
+			for (let e of this.#d.values()) t.deleteTexture(e.tex);
+			this.#p !== null && t.deleteTexture(this.#p), this.#a !== null && t.deleteVertexArray(this.#a), this.#o !== null && t.deleteVertexArray(this.#o), this.#r !== null && t.deleteProgram(this.#r), this.#i !== null && t.deleteProgram(this.#i), t.getExtension("WEBGL_lose_context")?.loseContext();
+		}
+		e?.remove(), this.#d.clear(), this.#f = 0, this.#p = null, this.#e = null, this.#t = null, this.#n = null, this.#v = null, this.#b = null;
+	}
+	onFatal(e) {
+		this.#N = e;
+	}
+	renderSpread(e, t, n) {
+		this.#v = t, this.#y = n?.fill ?? !1, this.#b = null, this.#P(t), this.#G();
+	}
+	#P(e) {
+		let t = e.left ?? e.right;
+		t && t.height && (this.#D = t.width / t.height);
+	}
+	beginFlip(e, t, n, r) {
+		let i = r?.fill ?? !1;
+		this.#x = 0, r?.curl && (this.#S = r.curl), r?.anchor && (this.#C = r.anchor), this.#T = i ? 0 : B(e), this.#E = i ? 0 : B(t), this.#P(t), i ? this.#b = {
+			underLeft: null,
+			underRight: null,
+			underFull: t.right ?? t.left,
+			front: e.right ?? e.left,
+			back: e.right ?? e.left,
+			dir: n === "forward" ? 1 : -1,
+			fill: !0
+		} : n === "forward" ? this.#b = {
+			underLeft: e.left,
+			underRight: t.right,
+			underFull: null,
+			front: e.right,
+			back: t.left,
+			dir: 1,
+			fill: !1
+		} : this.#b = {
+			underLeft: t.left,
+			underRight: e.right,
+			underFull: null,
+			front: e.left,
+			back: t.right,
+			dir: -1,
+			fill: !1
+		}, this.#G();
+	}
+	setFlipProgress(e, t) {
+		this.#x = e, this.#G();
+	}
+	setViewTransform(e, t, n) {
+		this.#g = {
+			scale: e,
+			tx: t,
+			ty: n
+		}, this.#G();
+	}
+	measure() {
+		let e = this.#e, t = e?.clientWidth ?? 0, n = e?.clientHeight ?? 0, r = this.#D > 0, i = r ? this.#F() : void 0, a = r ? this.#I() : void 0;
+		return {
+			containerWidth: t,
+			containerHeight: n,
+			pageWidth: t / 2,
+			pageHeight: n,
+			book: i,
+			content: a
+		};
+	}
+	#F() {
+		let e = this.#e, t = e?.clientWidth ?? 0, n = e?.clientHeight ?? 0;
+		if (this.#D <= 0 || t <= 0 || n <= 0) return {
+			x: 0,
+			y: 0,
+			width: t,
+			height: n
+		};
+		let r = (this.#y ? 1 : 2) * this.#D, i = t, a = n;
+		return r > t / n ? a = t / r : i = n * r, {
+			x: (t - i) / 2,
+			y: (n - a) / 2,
+			width: i,
+			height: a
+		};
+	}
+	#I() {
+		let e = this.#F();
+		return !this.#y && this.#v !== null && B(this.#v) !== 0 ? {
+			x: e.x + e.width / 4,
+			y: e.y,
+			width: e.width / 2,
+			height: e.height
+		} : e;
+	}
+	#L = (e) => {
+		e.preventDefault(), this.#A = !0, this.#M === null && (this.#M = setTimeout(() => this.#B(), R));
+	};
+	#R = () => {
+		this.#V(), this.#A = !1, this.#H(), this.#G();
+	};
+	#z = () => {
+		this.#t?.ownerDocument.visibilityState === "visible" && this.#G();
+	};
+	#B() {
+		this.#j || (this.#j = !0, this.#N?.());
+	}
+	#V() {
+		this.#M !== null && (clearTimeout(this.#M), this.#M = null);
+	}
+	#H() {
+		let e = this.#n;
+		if (e !== null) {
+			this.#r = E(e, A, j), this.#i = E(e, M, N);
+			for (let t of [
+				"uViewport",
+				"uRect",
+				"uView",
+				"uTex",
+				"uGutterSide"
+			]) this.#m[t] = e.getUniformLocation(this.#r, t);
+			for (let t of [
+				"uViewport",
+				"uView",
+				"uOriginX",
+				"uDir",
+				"uLeafW",
+				"uFront",
+				"uBack",
+				"uGloss",
+				"uAlpha"
+			]) this.#h[t] = e.getUniformLocation(this.#i, t);
+			this.#a = this.#U(e, this.#r), this.#W(e, this.#i), this.#d.clear(), this.#f = 0, this.#p = this.#te(e), e.useProgram(this.#r), e.uniform1i(this.#m.uTex ?? null, 0), e.useProgram(this.#i), e.uniform1i(this.#h.uFront ?? null, 0), e.uniform1i(this.#h.uBack ?? null, 1), e.clearColor(0, 0, 0, 0), e.enable(e.BLEND), e.blendFunc(e.ONE, e.ONE_MINUS_SRC_ALPHA);
+		}
+	}
+	#U(e, t) {
+		let n = e.createVertexArray(), r = e.createBuffer();
+		if (n === null || r === null) throw Error("WebglRenderer: could not create buffers.");
+		e.bindVertexArray(n), e.bindBuffer(e.ARRAY_BUFFER, r), e.bufferData(e.ARRAY_BUFFER, new Float32Array([
+			0,
+			0,
+			1,
+			0,
+			0,
+			1,
+			1,
+			1
+		]), e.STATIC_DRAW);
+		let i = e.getAttribLocation(t, "aUnit");
+		return e.enableVertexAttribArray(i), e.vertexAttribPointer(i, 2, e.FLOAT, !1, 0, 0), e.bindVertexArray(null), n;
+	}
+	#W(e, t) {
+		let n = [];
+		for (let e = 0; e < F; e++) for (let t = 0; t < P; t++) {
+			let r = e * 29 + t, i = r + 1, a = r + 29, o = a + 1;
+			n.push(r, a, i, i, a, o);
+		}
+		this.#l = n.length;
+		let r = e.createVertexArray();
+		this.#s = e.createBuffer(), this.#c = e.createBuffer();
+		let i = e.createBuffer(), a = e.createBuffer();
+		if (r === null || this.#s === null || this.#c === null || i === null || a === null) throw Error("WebglRenderer: could not create mesh buffers.");
+		e.bindVertexArray(r), e.bindBuffer(e.ARRAY_BUFFER, this.#s), e.bufferData(e.ARRAY_BUFFER, this.#u.positions, e.DYNAMIC_DRAW);
+		let o = e.getAttribLocation(t, "aPos");
+		e.enableVertexAttribArray(o), e.vertexAttribPointer(o, 3, e.FLOAT, !1, 0, 0), e.bindBuffer(e.ARRAY_BUFFER, this.#c), e.bufferData(e.ARRAY_BUFFER, this.#u.normals, e.DYNAMIC_DRAW);
+		let s = e.getAttribLocation(t, "aNormal");
+		e.enableVertexAttribArray(s), e.vertexAttribPointer(s, 3, e.FLOAT, !1, 0, 0), e.bindBuffer(e.ARRAY_BUFFER, i), e.bufferData(e.ARRAY_BUFFER, this.#u.uvs, e.STATIC_DRAW);
+		let c = e.getAttribLocation(t, "aUv");
+		e.enableVertexAttribArray(c), e.vertexAttribPointer(c, 2, e.FLOAT, !1, 0, 0), e.bindBuffer(e.ELEMENT_ARRAY_BUFFER, a), e.bufferData(e.ELEMENT_ARRAY_BUFFER, new Uint16Array(n), e.STATIC_DRAW), e.bindVertexArray(null), this.#o = r;
+	}
+	#G() {
+		let e = this.#n, t = this.#t;
+		e === null || t === null || this.#A || e.isContextLost() || (this.#ne(), e.clear(e.COLOR_BUFFER_BIT), this.#K(), this.#b === null ? this.#v !== null && this.#q() : this.#J());
+	}
+	#K() {
+		let e = this.#n, t = this.#t, n = t.width, r = t.height;
+		if (this.#D > 0) {
+			let e = (this.#y ? 1 : 2) * this.#D;
+			e > n / r ? (this.#O = n, this.#k = Math.round(n / e)) : (this.#k = r, this.#O = Math.round(r * e));
+		} else this.#O = n, this.#k = r;
+		let i = Math.round((n - this.#O) / 2), a = Math.round((r - this.#k) / 2);
+		e.viewport(i, a, this.#O, this.#k);
+	}
+	#q() {
+		let e = this.#O, t = this.#k, n = this.#v;
+		this.#w = this.#y ? 0 : B(n) * (e / 4), this.#X(), this.#y ? this.#Z({
+			x: 0,
+			y: 0,
+			w: e,
+			h: t
+		}, n.right ?? n.left) : (this.#Z({
+			x: 0,
+			y: 0,
+			w: e / 2,
+			h: t
+		}, n.left, +!!n.right), this.#Z({
+			x: e / 2,
+			y: 0,
+			w: e / 2,
+			h: t
+		}, n.right, n.left ? -1 : 0));
+	}
+	#J() {
+		let e = this.#n, t = this.#O, n = this.#k, r = this.#b;
+		if (this.#w = r.fill ? 0 : (this.#T + (this.#E - this.#T) * this.#x) * (t / 4), this.#X(), r.fill ? this.#Z({
+			x: 0,
+			y: 0,
+			w: t,
+			h: n
+		}, r.underFull) : (this.#Z({
+			x: 0,
+			y: 0,
+			w: t / 2,
+			h: n
+		}, r.underLeft, 1), this.#Z({
+			x: t / 2,
+			y: 0,
+			w: t / 2,
+			h: n
+		}, r.underRight, -1)), r.front === null && r.back === null) return;
+		let i = r.fill ? t : t / 2, a = r.fill ? r.dir > 0 ? 0 : t : t / 2;
+		w[this.#S].deform(this.#u, i, n, this.#x, {
+			y: this.#C.y,
+			fill: r.fill
+		}), e.bindBuffer(e.ARRAY_BUFFER, this.#s), e.bufferSubData(e.ARRAY_BUFFER, 0, this.#u.positions), e.bindBuffer(e.ARRAY_BUFFER, this.#c), e.bufferSubData(e.ARRAY_BUFFER, 0, this.#u.normals), this.#Q(e.TEXTURE0, r.front), this.#Q(e.TEXTURE1, r.back), e.activeTexture(e.TEXTURE0), e.useProgram(this.#i), e.bindVertexArray(this.#o), e.uniform2f(this.#h.uViewport ?? null, t, n), e.uniform3f(this.#h.uView ?? null, this.#g.scale, this.#g.tx * this.#_ + this.#w, this.#g.ty * this.#_), e.uniform1f(this.#h.uOriginX ?? null, a), e.uniform1f(this.#h.uDir ?? null, r.dir), e.uniform1f(this.#h.uLeafW ?? null, i), e.uniform1f(this.#h.uGloss ?? null, this.#S === "simple" ? 0 : 1), e.uniform1f(this.#h.uAlpha ?? null, r.fill ? this.#Y() : 1), e.drawElements(e.TRIANGLES, this.#l, e.UNSIGNED_SHORT, 0);
+	}
+	#Y() {
+		let e = this.#S === "roll" || this.#S === "simple" ? I : L, t = (this.#x - e) / (1 - e);
+		return t <= 0 ? 1 : t >= 1 ? 0 : (1 - t) ** 1.5;
+	}
+	#X() {
+		let e = this.#n;
+		e.useProgram(this.#r), e.bindVertexArray(this.#a), e.activeTexture(e.TEXTURE0), e.uniform2f(this.#m.uViewport ?? null, this.#O, this.#k), e.uniform3f(this.#m.uView ?? null, this.#g.scale, this.#g.tx * this.#_ + this.#w, this.#g.ty * this.#_);
+	}
+	#Z(e, t, n = 0) {
+		let r = this.#n;
+		t !== null && (this.#Q(r.TEXTURE0, t), r.uniform4f(this.#m.uRect ?? null, e.x, e.y, e.w, e.h), r.uniform1f(this.#m.uGutterSide ?? null, n), r.drawArrays(r.TRIANGLE_STRIP, 0, 4));
+	}
+	#Q(e, t) {
+		let n = this.#n;
+		n.activeTexture(e), n.bindTexture(n.TEXTURE_2D, t === null ? this.#p : this.#$(t));
+	}
+	#$(e) {
+		let t = this.#n, n = this.#d.get(e);
+		if (n !== void 0) return this.#d.delete(e), this.#d.set(e, n), n.tex;
+		let r = O(t);
+		k(t, r, e);
+		let i = e, a = i.width * i.height * 4;
+		return this.#d.set(e, {
+			tex: r,
+			bytes: a
+		}), this.#f += a, this.#ee(), r;
+	}
+	#ee() {
+		let e = this.#n;
+		for (let [t, n] of this.#d) {
+			if (this.#f <= z || this.#d.size <= 4) break;
+			this.#d.delete(t), this.#f -= n.bytes, e.deleteTexture(n.tex);
+		}
+	}
+	#te(e) {
+		let t = O(e);
+		return e.bindTexture(e.TEXTURE_2D, t), e.texImage2D(e.TEXTURE_2D, 0, e.RGBA, 1, 1, 0, e.RGBA, e.UNSIGNED_BYTE, new Uint8Array([
+			0,
+			0,
+			0,
+			0
+		])), t;
+	}
+	#ne() {
+		let e = this.#n, t = this.#t, n = this.#e;
+		if (e === null || t === null || n === null) return;
+		this.#_ = typeof devicePixelRatio == "number" ? devicePixelRatio : 1;
+		let r = Math.max(1, Math.round(n.clientWidth * this.#_)), i = Math.max(1, Math.round(n.clientHeight * this.#_));
+		(t.width !== r || t.height !== i) && (t.width = r, t.height = i, e.viewport(0, 0, r, i));
+	}
+};
+//#endregion
+export { V as WebglRenderer };
+
+//# sourceMappingURL=webglRenderer-Bg6VF4CW.js.map