@sliiu/present-transition-fx 0.0.0-stage → 0.1.1

package/dist/esm/webgl.js

@@ -0,0 +1,231 @@
+import * as fx2d from "./2d.js";
+import * as fx3d from "./3d.js";
+import { snapshotElement } from "./snapshot.js";
+import { ms } from "./util.js";
+function compile(gl, type, src) {
+    const sh = gl.createShader(type);
+    if (!sh)
+        return null;
+    gl.shaderSource(sh, src);
+    gl.compileShader(sh);
+    if (!gl.getShaderParameter(sh, gl.COMPILE_STATUS)) {
+        gl.deleteShader(sh);
+        return null;
+    }
+    return sh;
+}
+function program(gl, vs, fs) {
+    const v = compile(gl, gl.VERTEX_SHADER, vs);
+    const f = compile(gl, gl.FRAGMENT_SHADER, fs);
+    if (!v || !f)
+        return null;
+    const p = gl.createProgram();
+    if (!p)
+        return null;
+    gl.attachShader(p, v);
+    gl.attachShader(p, f);
+    gl.bindAttribLocation(p, 0, "aPos");
+    gl.linkProgram(p);
+    if (!gl.getProgramParameter(p, gl.LINK_STATUS)) {
+        gl.deleteProgram(p);
+        return null;
+    }
+    return p;
+}
+function uploadTexture(gl, canvas) {
+    const tex = gl.createTexture();
+    if (!tex)
+        return null;
+    gl.bindTexture(gl.TEXTURE_2D, tex);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    gl.pixelStorei(gl.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+    try {
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, canvas);
+    }
+    catch {
+        // 画布被跨域资源弄脏时浏览器抛 SecurityError。删掉纹理，让切换改走 CSS。
+        gl.deleteTexture(tex);
+        return null;
+    }
+    return tex;
+}
+const VS = `attribute vec2 aPos; varying vec2 vUv; void main(){ vUv = aPos * 0.5 + 0.5; gl_Position = vec4(aPos, 0.0, 1.0); }`;
+const FS_PAGE_CURL = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D uFrom;
+uniform sampler2D uTo;
+uniform float uProgress;
+const float MIN_AMOUNT = -0.16;
+const float MAX_AMOUNT = 1.5;
+float amount() { return uProgress * (MAX_AMOUNT - MIN_AMOUNT) + MIN_AMOUNT; }
+const float PI = 3.141592653589793;
+const float scale = 512.0;
+const float sharpness = 3.0;
+
+float cylinder(float r) {
+  float amt = amount();
+  return atan(r, 1.0 - amt);
+}
+
+void main() {
+  vec2 uv = vUv;
+  float a = amount();
+  float dist = (uv.x - 1.0) * (uv.x - 1.0) + (uv.y - 1.0) * (uv.y - 1.0);
+  vec2 fromCoord = uv;
+  vec4 colorFrom = texture2D(uFrom, fromCoord);
+  vec4 colorTo = texture2D(uTo, uv);
+  float radius = 0.1 + a * 0.4;
+  vec2 center = vec2(1.0 - a, 1.0 - a);
+  float d = length(uv - center);
+  float curl = smoothstep(radius, radius + 0.05, d);
+  vec4 res = mix(colorTo, colorFrom, curl);
+  // Shadow under the curl
+  float shadow = smoothstep(radius - 0.08, radius, d) * (1.0 - smoothstep(radius, radius + 0.04, d));
+  res.rgb *= 1.0 - 0.35 * shadow * (1.0 - uProgress);
+  gl_FragColor = res;
+}`;
+const FS_CUBE = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D uFrom;
+uniform sampler2D uTo;
+uniform float uProgress;
+uniform float uDir;
+void main() {
+  float p = uProgress;
+  vec2 uv = vUv;
+  float face = uv.x + (uDir > 0.0 ? -p : p);
+  if (face < 0.0 || face > 1.0) {
+    vec2 to = vec2(face < 0.0 ? face + 1.0 : face - 1.0, uv.y);
+    gl_FragColor = texture2D(uTo, to);
+  } else {
+    gl_FragColor = texture2D(uFrom, vec2(face, uv.y));
+  }
+}`;
+const FS_DISSOLVE = `
+precision highp float;
+varying vec2 vUv;
+uniform sampler2D uFrom;
+uniform sampler2D uTo;
+uniform float uProgress;
+float rand(vec2 co){ return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453); }
+void main(){
+  float n = rand(vUv);
+  gl_FragColor = (n < uProgress) ? texture2D(uTo, vUv) : texture2D(uFrom, vUv);
+}`;
+async function runWebGLTransition(ctx, fragment, uniforms = () => undefined) {
+    const w = ctx.stageSize.w;
+    const h = ctx.stageSize.h;
+    const cache = new Map();
+    const [from, to] = await Promise.all([
+        snapshotElement(ctx.ghost, w, h, cache),
+        snapshotElement(ctx.stage, w, h, cache),
+    ]);
+    if (!from || !to)
+        return false;
+    const canvas = document.createElement("canvas");
+    canvas.width = w;
+    canvas.height = h;
+    Object.assign(canvas.style, {
+        position: "absolute",
+        left: ctx.stage.style.left || `${ctx.stage.offsetLeft}px`,
+        top: ctx.stage.style.top || `${ctx.stage.offsetTop}px`,
+        width: ctx.stage.style.width || `${w}px`,
+        height: ctx.stage.style.height || `${h}px`,
+        transform: ctx.stage.style.transform || "",
+        transformOrigin: ctx.stage.style.transformOrigin || "center center",
+        zIndex: "3",
+        pointerEvents: "none",
+    });
+    const ghostVis = ctx.ghost.style.visibility;
+    const stageVis = ctx.stage.style.visibility;
+    let gl = null;
+    let succeeded = false;
+    ctx.stage.parentElement?.appendChild(canvas);
+    try {
+        gl = canvas.getContext("webgl", { premultipliedAlpha: true });
+        if (!gl)
+            return false;
+        const prog = program(gl, VS, fragment);
+        if (!prog)
+            return false;
+        const buf = gl.createBuffer();
+        gl.bindBuffer(gl.ARRAY_BUFFER, buf);
+        gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([-1, -1, 1, -1, -1, 1, 1, 1]), gl.STATIC_DRAW);
+        gl.enableVertexAttribArray(0);
+        gl.vertexAttribPointer(0, 2, gl.FLOAT, false, 0, 0);
+        const tFrom = uploadTexture(gl, from.canvas);
+        const tTo = uploadTexture(gl, to.canvas);
+        if (!tFrom || !tTo)
+            return false;
+        gl.useProgram(prog);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, tFrom);
+        gl.uniform1i(gl.getUniformLocation(prog, "uFrom"), 0);
+        gl.activeTexture(gl.TEXTURE1);
+        gl.bindTexture(gl.TEXTURE_2D, tTo);
+        gl.uniform1i(gl.getUniformLocation(prog, "uTo"), 1);
+        const uP = gl.getUniformLocation(prog, "uProgress");
+        uniforms(gl, prog);
+        ctx.ghost.style.visibility = "hidden";
+        ctx.stage.style.visibility = "hidden";
+        const duration = ms(ctx);
+        const start = performance.now();
+        const glCtx = gl;
+        await new Promise((resolve) => {
+            const step = () => {
+                try {
+                    const t = Math.min(1, (performance.now() - start) / Math.max(1, duration));
+                    glCtx.viewport(0, 0, canvas.width, canvas.height);
+                    glCtx.clearColor(0, 0, 0, 0);
+                    glCtx.clear(glCtx.COLOR_BUFFER_BIT);
+                    glCtx.uniform1f(uP, t);
+                    glCtx.drawArrays(glCtx.TRIANGLE_STRIP, 0, 4);
+                    if (t < 1)
+                        requestAnimationFrame(step);
+                    else
+                        resolve();
+                }
+                catch {
+                    resolve();
+                }
+            };
+            requestAnimationFrame(step);
+        });
+        succeeded = true;
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        canvas.remove();
+        ctx.stage.style.visibility = stageVis;
+        if (!succeeded)
+            ctx.ghost.style.visibility = ghostVis;
+        gl?.getExtension("WEBGL_lose_context")?.loseContext();
+    }
+}
+export const pageCurlWebGL = async (ctx) => {
+    const ok = await runWebGLTransition(ctx, FS_PAGE_CURL);
+    if (!ok)
+        await fx3d.pageCurl(ctx);
+};
+export const cubeWebGL = async (ctx) => {
+    const dir = String(ctx.params.dir ?? "left");
+    const ok = await runWebGLTransition(ctx, FS_CUBE, (gl, p) => {
+        gl.uniform1f(gl.getUniformLocation(p, "uDir"), dir === "left" || dir === "up" ? 1 : -1);
+    });
+    if (!ok)
+        await fx3d.cube(ctx);
+};
+export const boxWebGL = (ctx) => fx3d.box(ctx);
+export const dissolveWebGL = async (ctx) => {
+    const ok = await runWebGLTransition(ctx, FS_DISSOLVE);
+    if (!ok)
+        await fx2d.dissolve(ctx);
+};

package/dist/types/2d.d.ts

@@ -0,0 +1,40 @@
+import type { TransitionFactory } from "./types.js";
+export declare const fade: TransitionFactory;
+export declare const cut: TransitionFactory;
+export declare const push: TransitionFactory;
+export declare const cover: TransitionFactory;
+export declare const uncover: TransitionFactory;
+export declare const wipe: TransitionFactory;
+export declare const split: TransitionFactory;
+export declare const zoom: TransitionFactory;
+export declare const blinds: TransitionFactory;
+export declare const checker: TransitionFactory;
+export declare const randomBar: TransitionFactory;
+/** 旧页切成小格，按固定乱序一块块消失。着色器快照失败时用这条。 */
+export declare const dissolve: TransitionFactory;
+export declare const newsflash: TransitionFactory;
+export declare const wheel: TransitionFactory;
+export declare const wheelReverse: TransitionFactory;
+export declare const circle: TransitionFactory;
+export declare const diamond: TransitionFactory;
+export declare const plus: TransitionFactory;
+export declare const random: TransitionFactory;
+export declare const fall: TransitionFactory;
+export declare const reveal: TransitionFactory;
+export declare const flash: TransitionFactory;
+/** 菱形或六边形沿方向扫过，同时旧页闪几下。pattern 来自 OOXML hexagon / diamond。 */
+export declare const glitter: TransitionFactory;
+/** 疏六边形从中心铺开，格子之间留缝，不闪。 */
+export declare const honeycomb: TransitionFactory;
+/** 斜向细条撕开。向外从中心铺开新页，向内让旧页的细条收到中心。 */
+export declare const shred: TransitionFactory;
+/** 旧页切成小块飞散，新页从稍大缩回。 */
+export declare const fracture: TransitionFactory;
+/** 旧页向左掀起，一道高光扫过新页。 */
+export declare const prestige: TransitionFactory;
+/** 梳齿交错抽走旧页。水平是上下两排齿，垂直是左右两排齿。 */
+export declare const comb: TransitionFactory;
+/** 斜向宽带从指定角扫过。 */
+export declare const strips: TransitionFactory;
+/** 从中心张开一块扇形，和整圆轮子分开。 */
+export declare const wedge: TransitionFactory;

package/dist/types/3d.d.ts

@@ -0,0 +1,38 @@
+import type { TransitionFactory } from "./types.js";
+export declare const cube: TransitionFactory;
+/** 三棱柱转 120°，和立方体的 90° 分开。左右绕 Y，上下绕 X。 */
+export declare const prism: TransitionFactory;
+/** 走进盒子：新页从内侧转出来，旧页往外让开。和立方体外表面对转分开。 */
+export declare const box: TransitionFactory;
+export declare const gallery: TransitionFactory;
+export declare const orbit: TransitionFactory;
+export declare const conveyor: TransitionFactory;
+/** 旧页对开。垂直沿左右铰链转开，水平沿上下铰链转开。 */
+export declare const doors: TransitionFactory;
+/** 窗：两扇平着滑开，不绕铰链转。和门分开。 */
+export declare const window: TransitionFactory;
+export declare const pageCurl: TransitionFactory;
+/** p15 pageCurlSingle：只掀起一角。整页卷曲走 pageCurl 的书页翻边。 */
+export declare const pageCurlSingle: TransitionFactory;
+/** p15 wind：旧页切成细条，顺着风向依次吹出。向右 / 向下镜像。 */
+export declare const wind: TransitionFactory;
+/** p15 crush：旧页朝选定的边压成一条线。 */
+export declare const crush: TransitionFactory;
+export declare const airplane: TransitionFactory;
+/** 对折两次再飞走。向右时折痕在右缘。和翻页的单次卷起分开。 */
+export declare const origami: TransitionFactory;
+export declare const flythrough: TransitionFactory;
+export declare const rotate: TransitionFactory;
+/** 绕画面外侧的轴转过去，像摩天轮的一格，不是原地翻面。 */
+export declare const ferris: TransitionFactory;
+export declare const peelOff: TransitionFactory;
+/** 卡片翻面：转到 90° 时只看见棱，没有旋转那种半透明交叠。 */
+export declare const flip: TransitionFactory;
+/** 两页左右错身换位，带一点倾斜。 */
+export declare const switchFx: TransitionFactory;
+export declare const drape: TransitionFactory;
+/** 帘幕：多条竖褶从中缝向两边收走。 */
+export declare const curtains: TransitionFactory;
+export declare const ripple: TransitionFactory;
+export declare const warp: TransitionFactory;
+export declare const vortex: TransitionFactory;

package/dist/types/geometry.d.ts

@@ -0,0 +1,38 @@
+export type SplitMotion = {
+    kind: "expand";
+    clip: string;
+} | {
+    kind: "meet";
+    axis: "x" | "y";
+};
+/** orient=vert 左右分开，horz 上下分开。dir=in 从两侧收到中间，其余从中间向外展开。 */
+export declare function splitMotion(orient: unknown, dir: unknown): SplitMotion;
+/** 面板上的四档（中央向左右展开 / 左右向中央收缩 / …）和 OOXML orient+dir 互转。 */
+export declare function splitToken(orient: unknown, dir: unknown): string;
+export declare function splitParamsFromToken(token: string): {
+    orient: "horz" | "vert";
+    dir: "in" | "out";
+};
+/** OOXML CT_WheelTransition 的 spokes。缺省 4。界面提供 1/2/3/4/8，其它 1–8 的整数照播。 */
+export declare function wheelSpokes(pattern: unknown): number;
+/** 固定点数的轮辐多边形，portion 0 收成射线，1 铺满画面。reverse 往反方向张开。 */
+export declare function wheelPolygon(spokes: number, portion: number, reverse: boolean): string;
+/** 条纹沿 dir 扫过。dir 是运动方向（topLeft = 朝左上，即从右下进来）。三点同点数，方便插值。 */
+export declare function stripsClips(dir: string): [string, string, string];
+/** 涟漪收缩的圆心。角方向用面板的 topLeft / topRight / bottomLeft / bottomRight。 */
+export declare function rippleAt(dir: string): string;
+/** 闪耀的菱形 / 六边形，以及蜂巢的疏六边形。mask 里黑色是露出的部分。 */
+export declare function cellMask(kind: string): string;
+/** 面板上「方向 · 图案」和 params.dir + params.pattern 互转。缺省向左、菱形。 */
+export declare function glitterToken(dir: unknown, pattern: unknown): string;
+export declare function glitterParamsFromToken(token: string): {
+    dir: "left" | "right" | "up" | "down";
+    pattern: "diamond" | "hexagon";
+};
+/** 闪耀扫过的起点和终点。向左从左缘扫到右缘，其余镜像。 */
+export declare function glitterSweep(dir: string): {
+    from: string;
+    to: string;
+};
+/** 剥离后仍平贴的那一块。towardRight 从左下角往右揭，否则从右下角往左揭。amount 0 整页，1 几乎揭完。 */
+export declare function peelFlatClip(towardRight: boolean, amount: number): string;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { alignClosedPolylines, ellipsePathFromSize, flattenPathToPoints, makeMorphPathTween, morphPathCompatible, morphPathSignature, linePathFromPoints, parsePathCommands, pathToAbsolute, polygonPointsToPath, rectPathFromSize, } from "./morph-path.js";
+export { auditMorphDeck, auditMorphSlides, averageMorphIssuesPerPair, averageMorphReadinessPercent, averagePathMorphCoveragePercent, collectMorphCandidatesFromSlide, collectUnmatchedMorphShapesInDeck, countMorphPairsClean, countMorphPairsWithIssues, exportMorphAuditText, exportMorphDeckAuditText, exportMorphDeckCompactText, exportMorphDeckFilteredCompactText, exportMorphDeckIssuesCompactText, exportMorphDeckReadinessText, exportMorphIssuesCompactText, exportMorphPairCoverageText, exportMorphPairCompactText, exportMorphReadinessText, exportMorphUnmatchedShapesText, filterMorphDeckEntries, findFirstIssueMorphPair, findHighestPathCoverageMorphPair, findLowestPathCoverageMorphPair, findMostIssueMorphPair, findStrongestMorphPair, findWeakestMorphPair, formatMorphDeckChromeLines, formatMorphDeckReadinessLine, formatMorphDeckStatsLine, formatMorphLowestPathLine, formatMorphMatchReasonBreakdown, formatMorphPairCoverageBreakdownLine, formatMorphReadinessLine, formatMorphReadinessScoreLine, formatMorphReadinessSummary, morphCandidateFromShape, morphIssueCount, morphPairsWithIssues, morphReadinessPercent, countMorphDeckIssues, pathMorphCoveragePercent, summarizeMorphMatchReasons, } from "./morph-audit.js";
+export type { MorphAuditFilter, MorphAuditPair, MorphAuditReport, MorphDeckAuditEntry, MorphDeckEntryFilter, MorphMatchReasonKind, MorphUnmatchedShapeRef, } from "./morph-audit.js";
+export { matchMorphShapePairs, morphGeometryHash, morphMatchReason, morphSimilarity, } from "./morph-match.js";
+export * from "./types.js";
+export { cellMask, glitterParamsFromToken, glitterSweep, glitterToken, peelFlatClip, rippleAt, splitMotion, splitParamsFromToken, splitToken, stripsClips, wheelPolygon, wheelSpokes, } from "./geometry.js";
+export { getTransition, listTransitions, registerTransition, runTransition, } from "./registry.js";

package/dist/types/morph-audit.d.ts

@@ -0,0 +1,127 @@
+import type { Presentation, Shape, Slide } from "@sliiu/present-core";
+import { morphMatchReason, type MorphShapeCandidate } from "./morph-match.js";
+export type MorphAuditFilter = "all" | "path" | "flip" | "issues";
+export interface MorphAuditPair {
+    ghost: MorphShapeCandidate;
+    stage: MorphShapeCandidate;
+    pathMorph: boolean;
+}
+export interface MorphAuditReport {
+    ghostCount: number;
+    stageCount: number;
+    matched: number;
+    pathMorphCount: number;
+    flipOnlyCount: number;
+    unmatchedStage: MorphShapeCandidate[];
+    unmatchedGhost: MorphShapeCandidate[];
+    pairs: MorphAuditPair[];
+}
+/** Build a morph candidate from an in-memory shape (slide coordinates). */
+export declare function morphCandidateFromShape(shape: Shape): MorphShapeCandidate | null;
+/** Collect morph candidates from all visible layers on a slide (top-level shapes, as the player matches them). */
+export declare function collectMorphCandidatesFromSlide(slide: Slide): MorphShapeCandidate[];
+/** Analyze morph readiness between two slides (current → next). */
+export declare function auditMorphSlides(fromSlide: Slide, toSlide: Slide): MorphAuditReport;
+export declare function formatMorphReadinessSummary(report: MorphAuditReport): string;
+/** 0–100 morph readiness score for the slide pair. */
+export declare function morphReadinessPercent(report: MorphAuditReport): number;
+export type MorphMatchReasonKind = ReturnType<typeof morphMatchReason>;
+/** Count matched pairs by match reason (id / name / placeholder / geometry). */
+export declare function summarizeMorphMatchReasons(report: MorphAuditReport): Partial<Record<MorphMatchReasonKind, number>>;
+export declare function formatMorphMatchReasonBreakdown(report: MorphAuditReport): string;
+/** Unmatched shapes + FLIP-only pairs (actionable morph issues). */
+export declare function morphIssueCount(report: MorphAuditReport): number;
+export declare function averageMorphReadinessPercent(entries: readonly MorphDeckAuditEntry[]): number;
+export declare function findWeakestMorphPair(entries: readonly MorphDeckAuditEntry[]): MorphDeckAuditEntry | null;
+export declare function findStrongestMorphPair(entries: readonly MorphDeckAuditEntry[]): MorphDeckAuditEntry | null;
+export declare function formatMorphReadinessScoreLine(report: MorphAuditReport): string;
+/** Percent of matched pairs that use path morph (0–100). */
+export declare function pathMorphCoveragePercent(report: MorphAuditReport): number;
+export declare function countMorphDeckIssues(entries: readonly MorphDeckAuditEntry[]): number;
+export declare function morphPairsWithIssues(entries: readonly MorphDeckAuditEntry[]): MorphDeckAuditEntry[];
+/** Average path-morph coverage across adjacent slide pairs (0–100). */
+export declare function averagePathMorphCoveragePercent(entries: readonly MorphDeckAuditEntry[]): number;
+/** Slide pair with the most morph issues (ties → lowest from index). */
+export declare function findMostIssueMorphPair(entries: readonly MorphDeckAuditEntry[]): MorphDeckAuditEntry | null;
+/** Slide pair with the highest path-morph coverage (ties → lowest from index). */
+export declare function findHighestPathCoverageMorphPair(entries: readonly MorphDeckAuditEntry[]): MorphDeckAuditEntry | null;
+/** One-line morph readiness for chips and compact copy. */
+export declare function formatMorphReadinessLine(report: MorphAuditReport): string;
+/** Labeled readiness export for a single slide pair. */
+export declare function exportMorphReadinessText(report: MorphAuditReport, opts?: {
+    fromSlide?: number;
+    toSlide?: number;
+}): string;
+/** One-line deck morph readiness (stats + average path coverage). */
+export declare function formatMorphDeckReadinessLine(pres: Pick<Presentation, "slides">): string;
+/** Deck morph lines for the developer panel. Audits the deck once. */
+export declare function formatMorphDeckChromeLines(pres: Pick<Presentation, "slides">): {
+    stats: string;
+    readiness: string;
+    pairCoverage: string;
+    lowestPath: string;
+};
+/** Labeled deck readiness export for copy. */
+export declare function exportMorphDeckReadinessText(pres: Pick<Presentation, "slides">): string;
+/** Count of adjacent slide pairs with zero morph issues. */
+export declare function countMorphPairsClean(entries: readonly MorphDeckAuditEntry[]): number;
+/** Count of adjacent slide pairs with at least one morph issue. */
+export declare function countMorphPairsWithIssues(entries: readonly MorphDeckAuditEntry[]): number;
+/** Average morph issues per adjacent slide pair (0 if no pairs). */
+export declare function averageMorphIssuesPerPair(entries: readonly MorphDeckAuditEntry[]): number;
+/** First slide pair (lowest from index) with morph issues. */
+export declare function findFirstIssueMorphPair(entries: readonly MorphDeckAuditEntry[]): MorphDeckAuditEntry | null;
+/** Slide pair with the lowest path-morph coverage among pairs with matches (ties → lowest from index). */
+export declare function findLowestPathCoverageMorphPair(entries: readonly MorphDeckAuditEntry[]): MorphDeckAuditEntry | null;
+/** One-line pair coverage breakdown (clean / issues / avg issues). */
+export declare function formatMorphPairCoverageBreakdownLine(pres: Pick<Presentation, "slides">): string;
+/** One-line lowest path-coverage pair summary. */
+export declare function formatMorphLowestPathLine(pres: Pick<Presentation, "slides">): string;
+export interface MorphUnmatchedShapeRef {
+    slideIndex: number;
+    direction: "incoming" | "outgoing";
+    pairFromIndex: number;
+    id: string;
+    name: string;
+}
+/** Unmatched morph shapes across all adjacent slide pairs. */
+export declare function collectUnmatchedMorphShapesInDeck(pres: Pick<Presentation, "slides">): MorphUnmatchedShapeRef[];
+/** Plain-text report of unmatched morph shapes in the deck. */
+export declare function exportMorphUnmatchedShapesText(pres: Pick<Presentation, "slides">): string;
+/** Labeled pair-coverage export for copy. */
+export declare function exportMorphPairCoverageText(pres: Pick<Presentation, "slides">): string;
+export type MorphDeckEntryFilter = "all" | "issues" | "path" | "clean";
+export declare function filterMorphDeckEntries(entries: readonly MorphDeckAuditEntry[], filter?: MorphDeckEntryFilter): MorphDeckAuditEntry[];
+/** Compact deck pair list filtered by issues / path / clean. */
+export declare function exportMorphDeckFilteredCompactText(pres: Pick<Presentation, "slides">, filter?: MorphDeckEntryFilter): string;
+/** One-line deck morph stats for chips and compact copy. */
+export declare function formatMorphDeckStatsLine(pres: Pick<Presentation, "slides">): string;
+/** Compact single-pair morph summary (one-liners). */
+export declare function exportMorphPairCompactText(report: MorphAuditReport, opts?: {
+    fromSlide?: number;
+    toSlide?: number;
+}): string;
+/** Comma-separated deck pairs that have morph issues. */
+export declare function exportMorphDeckIssuesCompactText(pres: Pick<Presentation, "slides">): string;
+export interface MorphDeckAuditEntry {
+    fromIndex: number;
+    toIndex: number;
+    report: MorphAuditReport;
+}
+/** Audit morph readiness for every adjacent slide pair in a deck. */
+export declare function auditMorphDeck(pres: Pick<Presentation, "slides">): MorphDeckAuditEntry[];
+/** Plain-text morph audit across the whole deck. */
+export declare function exportMorphDeckAuditText(pres: Pick<Presentation, "slides">): string;
+/** Compact deck-wide morph summary for copy / support. */
+export declare function exportMorphDeckCompactText(pres: Pick<Presentation, "slides">): string;
+/** Short issues-only export (unmatched + FLIP-only pairs). */
+export declare function exportMorphIssuesCompactText(report: MorphAuditReport, opts?: {
+    fromSlide?: number;
+    toSlide?: number;
+}): string;
+/** Plain-text morph audit for copy / export. */
+export declare function exportMorphAuditText(report: MorphAuditReport, opts?: {
+    fromSlide?: number;
+    toSlide?: number;
+    filter?: MorphAuditFilter;
+}): string;

package/dist/types/morph-match.d.ts

@@ -0,0 +1,28 @@
+export interface MorphShapeRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export interface MorphShapeCandidate {
+    id: string;
+    name: string;
+    tag: string;
+    rect: MorphShapeRect;
+    pathD?: string;
+    placeholderType?: string;
+}
+export declare function morphGeometryHash(c: MorphShapeCandidate): string;
+export declare function morphSimilarity(a: MorphShapeCandidate, b: MorphShapeCandidate): number;
+/** How a morph pair was matched (mirrors `matchMorphShapePairs` priority). */
+export declare function morphMatchReason(ghost: MorphShapeCandidate, stage: MorphShapeCandidate): "id" | "name" | "placeholder" | "geometry";
+/**
+ * name/id/placeholder/geometry matching for morph FLIP (testable without DOM).
+ * Each tier is resolved for every shape before the next one, and geometry pairs are assigned
+ * best-score-first: a stage-order greedy pass lets an early shape take the ghost that an
+ * unchanged later shape (same kicker, same folio) matches exactly.
+ */
+export declare function matchMorphShapePairs(ghost: MorphShapeCandidate[], stage: MorphShapeCandidate[]): Array<{
+    ghost: MorphShapeCandidate;
+    stage: MorphShapeCandidate;
+}>;

package/dist/types/morph-path.d.ts

@@ -0,0 +1,37 @@
+/** SVG path helpers for Morph transitions (normalize + interpolate). */
+export interface PathCommand {
+    cmd: string;
+    args: number[];
+}
+interface Point {
+    x: number;
+    y: number;
+}
+export declare function parsePathCommands(d: string): PathCommand[];
+/** Convert relative path commands to absolute (uppercase) equivalents. */
+export declare function pathToAbsolute(commands: PathCommand[]): PathCommand[];
+/** Open line path in local coordinates. */
+export declare function linePathFromPoints(x1: number, y1: number, x2: number, y2: number): string;
+/** Closed rectangle path in local coordinates (0,0)–(w,h). */
+export declare function rectPathFromSize(w: number, h: number): string;
+/** Closed ellipse path approximated as a polyline in local bbox (w×h). */
+export declare function ellipsePathFromSize(w: number, h: number, segments?: number): string;
+/** Convert SVG polygon/polyline `points` attribute to a path `d` string. */
+export declare function polygonPointsToPath(points: string, closed: boolean): string;
+/**
+ * Rotate / reverse `b` so closed polylines align for smoother morph tweens.
+ * Exported for regression tests.
+ */
+export declare function alignClosedPolylines(a: Point[], b: Point[]): {
+    a: Point[];
+    b: Point[];
+};
+/** Sample absolute path commands into a polyline (Bezier / arc aware). */
+export declare function flattenPathToPoints(commands: PathCommand[], segmentsPerCurve?: number): Point[];
+/** Build a tween for morphing `fromD` → `toD`, or null when only FLIP should apply. */
+export declare function makeMorphPathTween(fromD: string, toD: string): ((t: number) => string) | null;
+/** Whether path geometry can morph (vs FLIP-only). */
+export declare function morphPathCompatible(fromD: string, toD: string): boolean;
+/** Compare two paths after normalization (for shape matching). */
+export declare function morphPathSignature(d: string): string;
+export {};

package/dist/types/morph.d.ts

@@ -0,0 +1,2 @@
+import type { TransitionFactory } from "./types.js";
+export declare const morph: TransitionFactory;

package/dist/types/registry.d.ts

@@ -0,0 +1,6 @@
+import type { SlideTransition } from "@sliiu/present-core";
+import type { TransitionFactory } from "./types.js";
+export declare function getTransition(kind: string): TransitionFactory | undefined;
+export declare function listTransitions(): string[];
+export declare function registerTransition(kind: string, fn: TransitionFactory): void;
+export declare function runTransition(ghost: HTMLElement, stage: HTMLElement, transition: SlideTransition): Promise<void>;

package/dist/types/snapshot.d.ts

@@ -0,0 +1,19 @@
+export interface Snapshot {
+    canvas: HTMLCanvasElement;
+    width: number;
+    height: number;
+}
+export type SnapshotCache = Map<string, Promise<string | null>>;
+export declare function isExternalSnapshotUrl(url: string): boolean;
+/** 把样式里的外部 url() 换成 data URL；换不掉的可见背景改成 none，避免再去拉取。 */
+export declare function rewriteCssForSnapshot(css: string, resolved: Map<string, string | null>): {
+    css: string;
+    droppedVisible: boolean;
+};
+/**
+ * 在克隆树上把外部图片换成 data URL，并拆掉会弄脏画布的 video / iframe。
+ * 返回 false 表示有一张可见图读不出来，快照不能代表这一页。
+ * 不改 live。
+ */
+export declare function sanitizeSnapshotClone(live: HTMLElement, clone: HTMLElement, cache?: SnapshotCache): Promise<boolean>;
+export declare function snapshotElement(el: HTMLElement, w: number, h: number, cache?: SnapshotCache): Promise<Snapshot | null>;

package/dist/types/twin.d.ts

@@ -0,0 +1,2 @@
+export declare function mountTwin(source: HTMLElement, clip: string): HTMLElement;
+export declare function dropTwins(twins: HTMLElement[], source: HTMLElement, prevVisibility: string): void;

package/dist/types/types.d.ts

@@ -0,0 +1,13 @@
+import type { SlideTransition } from "@sliiu/present-core";
+export interface TransitionCtx {
+    ghost: HTMLElement;
+    stage: HTMLElement;
+    duration: number;
+    params: Record<string, unknown>;
+    transition: SlideTransition;
+    stageSize: {
+        w: number;
+        h: number;
+    };
+}
+export type TransitionFactory = (ctx: TransitionCtx) => Promise<void>;

package/dist/types/util.d.ts

@@ -0,0 +1,12 @@
+import type { TransitionCtx } from "./types.js";
+export declare const STD_EASE = "cubic-bezier(0.4, 0, 0.2, 1)";
+export declare const LINEAR = "linear";
+export declare function dirVec(dir: string, w: number, h: number): {
+    dx: number;
+    dy: number;
+    axis: "x" | "y";
+    sign: 1 | -1;
+};
+export declare function runAll(anims: Animation[], cleanup?: () => void): Promise<void>;
+export declare function ms(ctx: TransitionCtx): number;
+export declare function easing(ctx: TransitionCtx): string;

package/dist/types/webgl.d.ts

@@ -0,0 +1,5 @@
+import type { TransitionFactory } from "./types.js";
+export declare const pageCurlWebGL: TransitionFactory;
+export declare const cubeWebGL: TransitionFactory;
+export declare const boxWebGL: TransitionFactory;
+export declare const dissolveWebGL: TransitionFactory;