@sliiu/present-renderer 0.0.0-stage → 0.1.1

package/dist/cjs/text-stacked.js

@@ -0,0 +1,82 @@
+"use strict";
+// 竖排堆叠（eaVert / wordArtVert / mongolianVert）共享类型与列拆分工具。
+// svg-backend 与 canvas-backend 同时依赖：保证两个后端的列拆分 / 列宽计算完全一致。
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildStackedGlyphs = buildStackedGlyphs;
+exports.wrapGlyphsIntoColumns = wrapGlyphsIntoColumns;
+const core_1 = require("@sliiu/present-core");
+const text_layout_1 = require("./text-layout");
+const text_shared_1 = require("./text-shared");
+// 半 / 全 / 零宽空白 + \t：作为竖排"列拆分点"，并在拆列后丢弃位于新列首部的此类空白。
+function isStackBreakWs(ch) {
+    return ch === " " || ch === "\t" || ch === "\u3000" || ch === "\u200B";
+}
+// 从段构建字符级 glyph：letterSpacing 加进 stepY；upright 标记是否直立
+// （仅 eaVert 下非 CJK 字符旋转 90° 侧躺）。
+function buildStackedGlyphs(p, para, vert, fieldCtx) {
+    const baseLh = (0, text_shared_1.lineHeightFactor)(p);
+    const glyphs = [];
+    for (const run of p.runs) {
+        const runText = fieldCtx ? (0, core_1.runDisplayText)(run, fieldCtx) : run.text;
+        const fs = (para?.fontSize ?? run.fontSize) ?? text_shared_1.FALLBACK_FONT_SIZE;
+        // ECMA-376 §21.1.2.3.10 rPr@spc — 竖排时 letterSpacing 作为字符间垂直额外步进。
+        const ls = run.letterSpacing ?? 0;
+        const stepY = (p.lineHeightPx ?? fs * baseLh) + ls;
+        for (const ch of Array.from(runText)) {
+            const cp = ch.codePointAt(0);
+            const upright = vert === "wordArtVert" || vert === "wordArtVertRtl" || vert === "mongolianVert"
+                ? true
+                : (0, text_layout_1.isEastAsianChar)(cp); // eaVert：仅 CJK 直立
+            glyphs.push({ ch, run, fontSize: fs, stepY, upright });
+        }
+    }
+    return glyphs;
+}
+// 把段内字符流按列高 maxH 拆成多列：
+// - 优先在最近一个空白字符处拆（空白随后丢弃，类似横排首字空白处理）；
+// - 若当前列还没有空白可拆，则在当前位置硬拆（避免单字单列死锁）；
+// - 新列首部一律去除空白。
+// 例：para 文本 "abc def" 高度 maxH 容下 5 个字符 → 拆为 ["abc", "def"]（首列尾空格被吃掉）。
+function wrapGlyphsIntoColumns(glyphs, maxH) {
+    const columns = [];
+    let curCol = [];
+    let curH = 0;
+    let lastBreakBefore = -1; // curCol 内"最近的空白"索引；在该位置拆 → 空白进下一列后被丢弃
+    for (const g of glyphs) {
+        const ws = isStackBreakWs(g.ch);
+        // 1) 列首抑制空白：当前列空 + 当前字符是空白 → 丢弃
+        if (curCol.length === 0 && ws)
+            continue;
+        // 2) 即将溢出：先尝试在 lastBreakBefore 拆，否则硬拆封口
+        if (curCol.length > 0 && curH + g.stepY > maxH) {
+            if (lastBreakBefore > 0) {
+                const left = curCol.slice(0, lastBreakBefore);
+                let right = curCol.slice(lastBreakBefore);
+                columns.push(left);
+                let i = 0;
+                while (i < right.length && isStackBreakWs(right[i].ch))
+                    i++;
+                right = right.slice(i);
+                curCol = right;
+                curH = curCol.reduce((acc, gg) => acc + gg.stepY, 0);
+                lastBreakBefore = -1;
+            }
+            else {
+                columns.push(curCol);
+                curCol = [];
+                curH = 0;
+                lastBreakBefore = -1;
+                if (ws)
+                    continue; // 新列首部继续抑制
+            }
+        }
+        if (ws && curCol.length > 0) {
+            lastBreakBefore = curCol.length; // 标记空白位置（"空白前可拆"）
+        }
+        curCol.push(g);
+        curH += g.stepY;
+    }
+    if (curCol.length > 0)
+        columns.push(curCol);
+    return columns;
+}

package/dist/cjs/text-warp.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warpActive = warpActive;
+exports.sampleWarpPath = sampleWarpPath;
+exports.placeGlyphsOnWarp = placeGlyphsOnWarp;
+exports.flattenWarpGlyphs = flattenWarpGlyphs;
+const text_shared_1 = require("./text-shared");
+const SKIP = new Set(["textNoShape", "textPlain", ""]);
+function warpActive(s) {
+    const prst = s.prstTxWarp?.prst;
+    return !!prst && !SKIP.has(prst);
+}
+function adj(av, key, fallback) {
+    const v = av?.[key];
+    if (v == null || !Number.isFinite(v))
+        return fallback;
+    // OOXML adj 多为 0..100000（百分比 × 1000）。已是 0..1 或像素时原样用。
+    if (Math.abs(v) <= 1)
+        return v;
+    if (Math.abs(v) <= 100)
+        return v / 100;
+    return v / 100000;
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function samplePolyline(pts, n) {
+    if (pts.length < 2)
+        return pts.map((p) => ({ ...p, angle: 0 }));
+    const seg = [0];
+    let total = 0;
+    for (let i = 1; i < pts.length; i++) {
+        const dx = pts[i].x - pts[i - 1].x;
+        const dy = pts[i].y - pts[i - 1].y;
+        total += Math.hypot(dx, dy);
+        seg.push(total);
+    }
+    if (total <= 0)
+        return pts.map((p) => ({ ...p, angle: 0 }));
+    const out = [];
+    const count = Math.max(2, n);
+    for (let i = 0; i < count; i++) {
+        const d = (i / (count - 1)) * total;
+        let k = 1;
+        while (k < seg.length && seg[k] < d)
+            k++;
+        const a = pts[k - 1];
+        const b = pts[Math.min(k, pts.length - 1)];
+        const len = seg[k] - seg[k - 1];
+        const t = len > 0 ? (d - seg[k - 1]) / len : 0;
+        const x = lerp(a.x, b.x, t);
+        const y = lerp(a.y, b.y, t);
+        const angle = (Math.atan2(b.y - a.y, b.x - a.x) * 180) / Math.PI;
+        out.push({ x, y, angle });
+    }
+    return out;
+}
+/** 同心外/内路径按同一参数下标配对（不要各自按弧长重采样，否则角度错位、径向厚度抖动）。 */
+function dualPath(outer, inner) {
+    const count = Math.min(outer.length, inner.length);
+    if (count < 2)
+        return [];
+    const out = [];
+    for (let k = 0; k < count; k++) {
+        const a = outer[k];
+        const b = inner[k];
+        const nxt = outer[Math.min(k + 1, count - 1)];
+        const prv = outer[Math.max(k - 1, 0)];
+        const angle = (Math.atan2(nxt.y - prv.y, nxt.x - prv.x) * 180) / Math.PI;
+        out.push({
+            x: (a.x + b.x) / 2,
+            y: (a.y + b.y) / 2,
+            angle,
+            radial: Math.max(1, Math.hypot(a.x - b.x, a.y - b.y)),
+        });
+    }
+    return out;
+}
+function offsetToward(pts, target, dist) {
+    const n = pts.length;
+    if (n < 2)
+        return pts;
+    return pts.map((p, i) => {
+        const nxt = pts[Math.min(i + 1, n - 1)];
+        const prv = pts[Math.max(i - 1, 0)];
+        const ang = Math.atan2(nxt.y - prv.y, nxt.x - prv.x);
+        let nx = -Math.sin(ang);
+        let ny = Math.cos(ang);
+        if (nx * (target.x - p.x) + ny * (target.y - p.y) < 0) {
+            nx = -nx;
+            ny = -ny;
+        }
+        return { x: p.x + nx * dist, y: p.y + ny * dist };
+    });
+}
+function envelopePath(prst, x, y, w, h, n) {
+    const cy = y + h / 2;
+    const topFlat = y + h * 0.12;
+    const botFlat = y + h * 0.88;
+    const minHalf = h * 0.12;
+    const maxHalf = h * 0.48;
+    const outer = [];
+    const inner = [];
+    for (let i = 0; i <= n; i++) {
+        const t = i / n;
+        const px = x + t * w;
+        const bulge = Math.sin(Math.PI * t);
+        const inflate = prst.startsWith("textInflate");
+        const half = inflate
+            ? minHalf + (maxHalf - minHalf) * bulge
+            : maxHalf - (maxHalf - minHalf) * bulge;
+        if (prst === "textInflateTop" || prst === "textDeflateTop") {
+            outer.push({ x: px, y: cy - half });
+            inner.push({ x: px, y: botFlat });
+        }
+        else if (prst === "textInflateBottom" || prst === "textDeflateBottom") {
+            outer.push({ x: px, y: topFlat });
+            inner.push({ x: px, y: cy + half });
+        }
+        else {
+            outer.push({ x: px, y: cy - half });
+            inner.push({ x: px, y: cy + half });
+        }
+    }
+    return dualPath(outer, inner);
+}
+function clamp(v, lo, hi) {
+    return Math.min(hi, Math.max(lo, v));
+}
+function arcPoints(cx, cy, rx, ry, a0, a1, n = 48) {
+    const pts = [];
+    for (let i = 0; i <= n; i++) {
+        const t = i / n;
+        const a = a0 + (a1 - a0) * t;
+        pts.push({ x: cx + Math.cos(a) * rx, y: cy + Math.sin(a) * ry });
+    }
+    return pts;
+}
+/** 在文字框内生成 warp 基线采样（沿路径从左到右）。 */
+function sampleWarpPath(prst, box, avLst) {
+    const { x, y, w, h } = box;
+    const cx = x + w / 2;
+    const cy = y + h / 2;
+    const amp = adj(avLst, "adj", 0.25);
+    const n = 64;
+    const wave = (periods, phase = 0) => {
+        const pts = [];
+        const a = Math.max(4, h * amp);
+        for (let i = 0; i <= n; i++) {
+            const t = i / n;
+            pts.push({
+                x: x + t * w,
+                y: cy + Math.sin((t * periods + phase) * Math.PI * 2) * a,
+            });
+        }
+        return pts;
+    };
+    switch (prst) {
+        case "textArchUp":
+            return samplePolyline(arcPoints(cx, y + h * 0.92, w / 2, -h * 0.82, Math.PI, 0), n);
+        case "textArchUpPour": {
+            const outer = arcPoints(cx, y + h * 0.92, w / 2, -h * 0.82, Math.PI, 0);
+            const band = Math.max(6, Math.min(w, h) * clamp(0.38 + amp * 0.25, 0.22, 0.7));
+            return dualPath(outer, offsetToward(outer, { x: cx, y: cy }, band));
+        }
+        case "textArchDown":
+            return samplePolyline(arcPoints(cx, y + h * 0.08, w / 2, h * 0.82, Math.PI, 0), n);
+        case "textArchDownPour": {
+            const outer = arcPoints(cx, y + h * 0.08, w / 2, h * 0.82, Math.PI, 0);
+            const band = Math.max(6, Math.min(w, h) * clamp(0.38 + amp * 0.25, 0.22, 0.7));
+            return dualPath(outer, offsetToward(outer, { x: cx, y: cy }, band));
+        }
+        case "textArchLeft":
+            return samplePolyline(arcPoints(x + w * 0.92, cy, w * 0.82, h / 2, -Math.PI / 2, -3 * Math.PI / 2), n);
+        case "textArchLeftPour": {
+            const outer = arcPoints(x + w * 0.92, cy, w * 0.82, h / 2, -Math.PI / 2, -3 * Math.PI / 2);
+            const band = Math.max(6, Math.min(w, h) * clamp(0.38 + amp * 0.25, 0.22, 0.7));
+            return dualPath(outer, offsetToward(outer, { x: cx, y: cy }, band));
+        }
+        case "textArchRight":
+            return samplePolyline(arcPoints(x + w * 0.08, cy, w * 0.82, h / 2, -Math.PI / 2, Math.PI / 2), n);
+        case "textArchRightPour": {
+            const outer = arcPoints(x + w * 0.08, cy, w * 0.82, h / 2, -Math.PI / 2, Math.PI / 2);
+            const band = Math.max(6, Math.min(w, h) * clamp(0.38 + amp * 0.25, 0.22, 0.7));
+            return dualPath(outer, offsetToward(outer, { x: cx, y: cy }, band));
+        }
+        case "textLeft":
+            return samplePolyline([
+                { x: x + w * 0.08, y },
+                { x: x + w * 0.08, y: y + h },
+            ], n);
+        case "textRight":
+            return samplePolyline([
+                { x: x + w * 0.92, y },
+                { x: x + w * 0.92, y: y + h },
+            ], n);
+        case "textUp":
+            return samplePolyline([
+                { x: cx, y: y + h },
+                { x: cx, y },
+            ], n);
+        case "textDown":
+            return samplePolyline([
+                { x: cx, y },
+                { x: cx, y: y + h },
+            ], n);
+        case "textCircle":
+        case "textButton":
+        case "textRingOutside":
+            return samplePolyline(arcPoints(cx, cy, w / 2 * 0.92, h / 2 * 0.92, Math.PI, Math.PI * 3), n);
+        case "textRingInside":
+            return samplePolyline(arcPoints(cx, cy, w / 2 * (0.42 + amp * 0.2), h / 2 * (0.42 + amp * 0.2), Math.PI, Math.PI * 3), n);
+        case "textCirclePour":
+        case "textButtonPour": {
+            const outer = arcPoints(cx, cy, w / 2 * 0.92, h / 2 * 0.92, Math.PI, Math.PI * 3);
+            const band = Math.max(6, Math.min(w, h) * clamp(0.36 + amp * 0.25, 0.2, 0.65));
+            return dualPath(outer, offsetToward(outer, { x: cx, y: cy }, band));
+        }
+        case "textWave1":
+        case "textDoubleWave1":
+            return samplePolyline(wave(1), n);
+        case "textWave2":
+        case "textWave4":
+            return samplePolyline(wave(2), n);
+        case "textCurveUp":
+        case "textCanUp":
+            return samplePolyline([
+                { x, y: y + h * 0.72 },
+                { x: cx, y: y + h * 0.22 },
+                { x: x + w, y: y + h * 0.72 },
+            ], n);
+        case "textCurveDown":
+        case "textCanDown":
+            return samplePolyline([
+                { x, y: y + h * 0.28 },
+                { x: cx, y: y + h * 0.78 },
+                { x: x + w, y: y + h * 0.28 },
+            ], n);
+        case "textChevron":
+        case "textChevronInverted": {
+            const up = prst === "textChevron";
+            const midY = up ? y + h * 0.28 : y + h * 0.72;
+            const sideY = up ? y + h * 0.72 : y + h * 0.28;
+            return samplePolyline([
+                { x, y: sideY },
+                { x: cx, y: midY },
+                { x: x + w, y: sideY },
+            ], n);
+        }
+        case "textTriangle":
+        case "textTriangleInverted": {
+            const up = prst === "textTriangle";
+            const top = up ? y + h * 0.2 : y + h * 0.8;
+            const bot = up ? y + h * 0.8 : y + h * 0.2;
+            return samplePolyline([
+                { x, y: bot },
+                { x: cx, y: top },
+                { x: x + w, y: bot },
+            ], n);
+        }
+        case "textStop":
+            return samplePolyline([
+                { x, y: cy },
+                { x: x + w * 0.12, y: y + h * 0.28 },
+                { x: x + w * 0.88, y: y + h * 0.28 },
+                { x: x + w, y: cy },
+            ], n);
+        case "textSlantUp":
+            return samplePolyline([
+                { x, y: y + h * 0.78 },
+                { x: x + w, y: y + h * 0.22 },
+            ], n);
+        case "textSlantDown":
+            return samplePolyline([
+                { x, y: y + h * 0.22 },
+                { x: x + w, y: y + h * 0.78 },
+            ], n);
+        case "textCascadeUp":
+            return samplePolyline([
+                { x, y: y + h * 0.7 },
+                { x: x + w, y: y + h * 0.3 },
+            ], n);
+        case "textCascadeDown":
+            return samplePolyline([
+                { x, y: y + h * 0.3 },
+                { x: x + w, y: y + h * 0.7 },
+            ], n);
+        case "textInflate":
+        case "textInflateTop":
+        case "textInflateBottom":
+        case "textDeflate":
+        case "textDeflateTop":
+        case "textDeflateBottom":
+            return envelopePath(prst, x, y, w, h, n);
+        default:
+            return samplePolyline([
+                { x, y: cy },
+                { x: x + w, y: cy },
+            ], n);
+    }
+}
+function glyphScaleY(prst, t) {
+    switch (prst) {
+        case "textInflate":
+        case "textInflateBottom":
+        case "textInflateTop":
+            return 1 + 0.45 * Math.sin(Math.PI * t);
+        case "textDeflate":
+        case "textDeflateBottom":
+        case "textDeflateTop":
+        case "textDeflateInflate":
+        case "textDeflateInflateDeflate":
+            return Math.max(0.35, 1 - 0.45 * Math.sin(Math.PI * t));
+        case "textFadeRight":
+            return Math.max(0.25, 1 - 0.75 * t);
+        case "textFadeLeft":
+            return Math.max(0.25, 0.25 + 0.75 * t);
+        case "textFadeUp":
+        case "textFadeDown":
+            return Math.max(0.25, 0.35 + 0.65 * (prst === "textFadeUp" ? t : 1 - t));
+        case "textCascadeUp":
+        case "textCascadeDown":
+            return 0.55 + 0.7 * t;
+        default:
+            return 1;
+    }
+}
+function placeGlyphsOnWarp(glyphs, samples, prst) {
+    const total = glyphs.reduce((a, g) => a + g.width, 0);
+    if (!samples.length || total <= 0)
+        return [];
+    let acc = 0;
+    const out = [];
+    for (const g of glyphs) {
+        const t = (acc + g.width / 2) / total;
+        const idx = Math.min(samples.length - 1, Math.max(0, t * (samples.length - 1)));
+        const i0 = Math.floor(idx);
+        const i1 = Math.min(samples.length - 1, i0 + 1);
+        const f = idx - i0;
+        const a = samples[i0];
+        const b = samples[i1];
+        const radial = a.radial != null && b.radial != null ? lerp(a.radial, b.radial, f) : undefined;
+        out.push({
+            ch: g.ch,
+            x: lerp(a.x, b.x, f),
+            y: lerp(a.y, b.y, f),
+            angle: lerp(a.angle, b.angle, f),
+            scaleY: radial != null && g.fontSize > 0
+                ? Math.max(0.35, radial / g.fontSize)
+                : glyphScaleY(prst ?? "", t),
+            run: g.run,
+            fontSize: g.fontSize,
+        });
+        acc += g.width;
+    }
+    return out;
+}
+function flattenWarpGlyphs(s, measure) {
+    const out = [];
+    for (const p of s.paragraphs) {
+        for (const run of p.runs) {
+            const fs = run.fontSize ?? p.defRunStyle?.fontSize ?? text_shared_1.FALLBACK_FONT_SIZE;
+            for (const ch of Array.from(run.text ?? "")) {
+                if (ch === "\n")
+                    continue;
+                const width = measure(run, ch) + (run.letterSpacing ?? 0);
+                out.push({ ch, width, run, fontSize: fs });
+            }
+        }
+        if (p !== s.paragraphs[s.paragraphs.length - 1]) {
+            const last = out[out.length - 1];
+            if (last)
+                out.push({ ch: " ", width: last.fontSize * 0.3, run: last.run, fontSize: last.fontSize });
+        }
+    }
+    return out;
+}

package/dist/cjs/text-wordart.js

@@ -0,0 +1,33 @@
+"use strict";
+// fromWordArt：老艺术字把字号当排版起点，画面上的字形要铺满形状框。
+// WPS / PowerPoint 对 `bodyPr@fromWordArt="1"` 做非均匀拉伸：墨迹外接矩形贴到
+// xfrm 的外框。`sz` 仍是文件里的字号，渲染时不改模型，导出仍写原值。
+//
+// textPlain / textNoShape 没有这个标志时仍按普通文本排，不在这里拉伸。
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordArtFitTransform = wordArtFitTransform;
+const MIN_INK = 0.5;
+const MAX_SCALE = 8;
+/**
+ * 把已排好的墨迹框映射到形状框。
+ * 变换顺序是先缩放再平移：`x' = x * sx + tx`。
+ * 近乎 1:1 或比例离谱时返回 null，调用方保持原排版。
+ */
+function wordArtFitTransform(ink, box) {
+    if (!(ink.w > MIN_INK && ink.h > MIN_INK && box.w > MIN_INK && box.h > MIN_INK))
+        return null;
+    const sx = box.w / ink.w;
+    const sy = box.h / ink.h;
+    if (!Number.isFinite(sx) || !Number.isFinite(sy))
+        return null;
+    if (sx > MAX_SCALE || sy > MAX_SCALE || sx < 1 / MAX_SCALE || sy < 1 / MAX_SCALE)
+        return null;
+    if (Math.abs(sx - 1) < 0.02 && Math.abs(sy - 1) < 0.02)
+        return null;
+    return {
+        sx,
+        sy,
+        tx: box.x - ink.x * sx,
+        ty: box.y - ink.y * sy,
+    };
+}

package/dist/cjs/video-frame.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVideoPosterFrame = getVideoPosterFrame;
+exports.waitForVideoFrames = waitForVideoFrames;
+const cache = new Map();
+function cacheKey(src, seekTo) {
+    return `${src}#t=${seekTo.toFixed(3)}`;
+}
+function getVideoPosterFrame(src, onReady, seekTo = 0.08) {
+    if (typeof document === "undefined" || !src)
+        return null;
+    if (src.startsWith("file:"))
+        return null;
+    const key = cacheKey(src, seekTo);
+    const hit = cache.get(key);
+    if (hit?.status === "ready")
+        return hit.img;
+    if (hit?.status === "failed")
+        return null;
+    if (hit?.status === "pending") {
+        if (onReady)
+            void hit.wait.then(() => onReady());
+        return null;
+    }
+    const wait = captureFrame(src, seekTo).then((img) => {
+        if (img) {
+            cache.set(key, { status: "ready", img });
+            onReady?.();
+        }
+        else {
+            cache.set(key, { status: "failed" });
+        }
+    });
+    cache.set(key, { status: "pending", wait });
+    return null;
+}
+function waitForVideoFrames(timeoutMs = 8000) {
+    const pending = [];
+    for (const e of cache.values()) {
+        if (e.status === "pending")
+            pending.push(e.wait);
+    }
+    if (!pending.length)
+        return Promise.resolve();
+    return Promise.race([
+        Promise.all(pending).then(() => undefined),
+        new Promise((resolve) => setTimeout(resolve, timeoutMs)),
+    ]);
+}
+function captureFrame(src, seekTo) {
+    return new Promise((resolve) => {
+        const video = document.createElement("video");
+        video.muted = true;
+        video.playsInline = true;
+        video.preload = "auto";
+        if (!src.startsWith("data:") && !src.startsWith("blob:"))
+            video.crossOrigin = "anonymous";
+        let settled = false;
+        const done = (img) => {
+            if (settled)
+                return;
+            settled = true;
+            video.removeAttribute("src");
+            video.load();
+            resolve(img);
+        };
+        const grab = () => {
+            try {
+                const w = video.videoWidth;
+                const h = video.videoHeight;
+                if (!w || !h) {
+                    done(null);
+                    return;
+                }
+                const c = document.createElement("canvas");
+                c.width = w;
+                c.height = h;
+                const ctx = c.getContext("2d");
+                if (!ctx) {
+                    done(null);
+                    return;
+                }
+                ctx.drawImage(video, 0, 0);
+                const url = c.toDataURL("image/jpeg", 0.72);
+                const img = new Image();
+                img.onload = () => done(img);
+                img.onerror = () => done(null);
+                img.src = url;
+            }
+            catch {
+                done(null);
+            }
+        };
+        video.addEventListener("error", () => done(null), { once: true });
+        video.addEventListener("loadeddata", () => {
+            const dur = Number.isFinite(video.duration) ? video.duration : 0;
+            const t = Math.max(0, dur > 0 ? Math.min(seekTo, Math.max(0, dur - 0.05)) : seekTo);
+            if (t <= 0.001 && video.readyState >= 2) {
+                grab();
+                return;
+            }
+            video.addEventListener("seeked", grab, { once: true });
+            try {
+                video.currentTime = t;
+            }
+            catch {
+                grab();
+            }
+        }, { once: true });
+        video.src = src;
+        setTimeout(() => done(null), 8000);
+    });
+}