polotno-node 2.15.19 → 3.0.1

package/lib/instance.js

@@ -0,0 +1,740 @@
+import path from "path";
+import fs from "fs";
+import os from "os";
+import crypto from "crypto";
+import { execSync } from "child_process";
+import { pathToFileURL, fileURLToPath } from "url";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { assertValidDesign } from "@polotno/schema";
+import * as fontCache from "./font-cache.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Compiled to lib/instance.js; the client bundle is published to ../dist.
+const DEFAULT_CLIENT = `file:${path.join(__dirname, "..", "dist", "index.html")}`;
+// Walk Polotno nodes recursively (depth-first)
+// cb(node) may return true to stop traversing the current branch early
+const forEveryChild = (node, cb) => {
+    if (!node || !node.children)
+        return;
+    for (const child of node.children) {
+        const shouldStop = cb(child);
+        if (shouldStop === true) {
+            break;
+        }
+        forEveryChild(child, cb);
+    }
+};
+// Collect pointers to all media objects that can have `src` rewritten.
+// Returned entries look like: { kind: 'video'|'audio', target: <object>, key: 'src' }
+const collectMediaSourcePointers = (json) => {
+    const pointers = [];
+    // videos in elements tree
+    for (const page of json?.pages || []) {
+        for (const el of page?.children || []) {
+            if (el?.type === "video" && typeof el.src === "string") {
+                pointers.push({ kind: "video", target: el, key: "src" });
+            }
+            forEveryChild(el, (child) => {
+                if (child?.type === "video" && typeof child.src === "string") {
+                    pointers.push({ kind: "video", target: child, key: "src" });
+                }
+            });
+        }
+    }
+    // audios array
+    for (const audio of json?.audios || []) {
+        if (audio && typeof audio.src === "string") {
+            pointers.push({ kind: "audio", target: audio, key: "src" });
+        }
+    }
+    return pointers;
+};
+const isDataOrFileSrc = (src) => {
+    if (typeof src !== "string")
+        return true;
+    return (src.startsWith("data:") ||
+        src.startsWith("file:") ||
+        src.startsWith("blob:"));
+};
+const guessExtension = (urlString, contentType) => {
+    try {
+        const u = new URL(urlString);
+        const ext = path.extname(u.pathname || "");
+        if (ext)
+            return ext;
+    }
+    catch (e) {
+        // ignore; fallback to content-type
+    }
+    const ct = String(contentType || "")
+        .split(";")[0]
+        .trim()
+        .toLowerCase();
+    const map = {
+        "video/mp4": ".mp4",
+        "video/webm": ".webm",
+        "video/quicktime": ".mov",
+        "audio/mpeg": ".mp3",
+        "audio/mp4": ".m4a",
+        "audio/wav": ".wav",
+        "audio/x-wav": ".wav",
+        "audio/ogg": ".ogg",
+        "audio/webm": ".webm",
+    };
+    return map[ct] || ".bin";
+};
+const downloadUrlToFile = async (urlString, destinationPath) => {
+    if (typeof fetch !== "function") {
+        throw new Error("Global fetch API is not available in this Node.js runtime. Please use Node 18+.");
+    }
+    const MAX_ATTEMPTS = 3;
+    const BASE_DELAY_MS = 300;
+    let lastError = null;
+    for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+        try {
+            // Ensure no partial file exists from previous attempts
+            await fs.promises.rm(destinationPath, { force: true });
+            const res = await fetch(urlString);
+            if (!res.ok) {
+                // Best-effort read of error body (small) for debugging.
+                let bodyPreview = "";
+                try {
+                    bodyPreview = await res.text();
+                    if (bodyPreview.length > 500) {
+                        bodyPreview = bodyPreview.slice(0, 500) + "...";
+                    }
+                }
+                catch (e) {
+                    // ignore
+                }
+                const details = [
+                    `${res.status} ${res.statusText}`.trim(),
+                    bodyPreview ? `body: ${JSON.stringify(bodyPreview)}` : null,
+                ]
+                    .filter(Boolean)
+                    .join(", ");
+                throw new Error(`HTTP error while downloading: ${details}`);
+            }
+            if (!res.body) {
+                throw new Error("Empty response body");
+            }
+            await pipeline(Readable.fromWeb(res.body), fs.createWriteStream(destinationPath));
+            return res.headers.get("content-type") || "";
+        }
+        catch (e) {
+            lastError = e;
+            if (attempt < MAX_ATTEMPTS) {
+                const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                await new Promise((r) => setTimeout(r, delay));
+                continue;
+            }
+        }
+    }
+    const message = lastError && lastError.message ? lastError.message : String(lastError);
+    throw new Error(`Failed to download media after ${MAX_ATTEMPTS} attempts: ${urlString}\nLast error: ${message}`);
+};
+// Returns a human-readable reason string if the video file needs transcoding
+// for Chromium headless compatibility, or null if it is already render-safe.
+const getVideoNormalizationReason = (filePath) => {
+    try {
+        const raw = execSync(`ffprobe -v error -select_streams v:0 -show_entries stream=codec_name,codec_tag_string,pix_fmt -of json "${filePath}"`, { encoding: "utf8" });
+        const info = JSON.parse(raw);
+        const vs = info?.streams?.[0];
+        if (!vs)
+            return null;
+        const codec = (vs.codec_name || "").toLowerCase();
+        const tag = (vs.codec_tag_string || "").toLowerCase();
+        if (["hevc", "h265"].includes(codec) || ["hvc1", "hev1"].includes(tag)) {
+            return "HEVC/H.265 is not supported by Chromium headless";
+        }
+        const pix = (vs.pix_fmt || "").toLowerCase();
+        if (pix && pix !== "yuv420p") {
+            return `pixel format "${pix}" is not the preferred yuv420p`;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+};
+const isFfmpegAvailable = () => {
+    try {
+        execSync("ffmpeg -version", { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+const getAudioCodec = (filePath) => {
+    try {
+        const result = execSync(`ffprobe -v error -select_streams a:0 -show_entries stream=codec_name -of csv=p=0 "${filePath}"`, { encoding: "utf8" });
+        return result.trim();
+    }
+    catch {
+        return null;
+    }
+};
+const convertAudioToAac = (inputPath, outputPath) => {
+    execSync(`ffmpeg -y -i "${inputPath}" -c:v copy -c:a aac "${outputPath}"`, {
+        stdio: "ignore",
+    });
+};
+const prepareLocalMediaForVideoExport = async (json) => {
+    const clonedJson = JSON.parse(JSON.stringify(json));
+    const pointers = collectMediaSourcePointers(clonedJson);
+    const rewriteMap = new Map();
+    const urlsToDownload = [];
+    const videoUrls = new Set();
+    for (const p of pointers) {
+        const src = p.target[p.key];
+        if (isDataOrFileSrc(src))
+            continue;
+        try {
+            const u = new URL(src);
+            if (u.protocol !== "http:" && u.protocol !== "https:")
+                continue;
+        }
+        catch (e) {
+            continue;
+        }
+        if (!rewriteMap.has(src)) {
+            rewriteMap.set(src, null);
+            urlsToDownload.push(src);
+        }
+        if (p.kind === "video")
+            videoUrls.add(src);
+    }
+    if (urlsToDownload.length === 0) {
+        return { json: clonedJson, cleanup: async () => { } };
+    }
+    const tempDir = await fs.promises.mkdtemp(path.join(os.tmpdir(), "polotno-node-assets-"));
+    let didCleanup = false;
+    const cleanup = async () => {
+        if (didCleanup)
+            return;
+        didCleanup = true;
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+    };
+    try {
+        await Promise.all(urlsToDownload.map(async (src) => {
+            const tmpBase = crypto.randomUUID
+                ? crypto.randomUUID()
+                : crypto.randomBytes(16).toString("hex");
+            const tmpPath = path.join(tempDir, tmpBase);
+            const contentType = await downloadUrlToFile(src, tmpPath);
+            const ext = guessExtension(src, contentType);
+            let finalPath = tmpPath + ext;
+            await fs.promises.rename(tmpPath, finalPath);
+            if (videoUrls.has(src)) {
+                const reason = getVideoNormalizationReason(finalPath);
+                if (reason) {
+                    const normalizedPath = finalPath + ".normalized.mp4";
+                    execSync(`ffmpeg -y -i "${finalPath}" -c:v libx264 -pix_fmt yuv420p -c:a aac -movflags +faststart "${normalizedPath}"`, { stdio: "ignore" });
+                    finalPath = normalizedPath;
+                }
+            }
+            rewriteMap.set(src, pathToFileURL(finalPath).toString());
+        }));
+        for (const p of pointers) {
+            const src = p.target[p.key];
+            const replacement = rewriteMap.get(src);
+            if (replacement) {
+                p.target[p.key] = replacement;
+            }
+        }
+        return { json: clonedJson, cleanup };
+    }
+    catch (e) {
+        await cleanup();
+        throw e;
+    }
+};
+export const createPage = async (browser, url, requestInterceptor, useFontCache = true) => {
+    const page = await browser.newPage();
+    // Attach request interceptor if provided
+    if (useFontCache || typeof requestInterceptor === "function") {
+        await page.setRequestInterception(true);
+        page.on("request", (request) => {
+            if (useFontCache && fontCache.tryRespond(request)) {
+                return;
+            }
+            if (typeof requestInterceptor === "function") {
+                requestInterceptor(request);
+            }
+            else {
+                request.continue().catch(() => { });
+            }
+        });
+        if (useFontCache) {
+            page.on("response", (response) => fontCache.capture(response));
+        }
+    }
+    // we need to make sure that headless is inside user agent
+    // because we use it for key validation check
+    // but also lets NOT just overwrite default one, because Google Fonts may send "reduced" version of font
+    // so some languages may not work
+    const userAgent = await page.evaluate(() => navigator.userAgent);
+    if (userAgent.indexOf("Headless") === -1) {
+        await page.setUserAgent(userAgent + " Chrome Headless");
+    }
+    page.on("console", (msg) => {
+        msg.args().forEach(async (message) => {
+            // skip style information
+            if (message.toString().indexOf("margin") >= 0) {
+                return;
+            }
+            const { subtype, description } = message.remoteObject();
+            if (subtype === "error") {
+                console.error(description);
+                return;
+            }
+            const text = message
+                .toString()
+                .replace("JSHandle:", "")
+                .replace("%c", "");
+            console.log(text);
+        });
+    });
+    page.on("pageerror", (msg) => {
+        console.error(msg);
+    });
+    await page.goto(url);
+    return page;
+};
+export const run = async (page, func, args) => {
+    return await page.evaluate(func, ...args);
+};
+// In-page export recipes. These run inside the browser (via page.evaluate / run),
+// so they may only reference page globals (`store`, `window`) — not module scope.
+// Defining them once lets the instance methods and the module-level page-taking
+// exports share a single recipe per export format.
+const recipeToDataURL = async (json, attrs) => {
+    const pixelRatio = attrs.pixelRatio || 1;
+    store.loadJSON(json);
+    store.setElementsPixelRatio(pixelRatio);
+    await store.waitLoading();
+    return store.toDataURL({ ...attrs, pixelRatio });
+};
+const recipeToPDFDataURL = async (json, attrs) => {
+    store.loadJSON(json);
+    // Honor an `onProgress` callback exposed by the instance `run()`. When it is
+    // not exposed (e.g. the module-level page-taking export) this is a no-op.
+    if (window.onProgress) {
+        attrs.onProgress = (progress) => {
+            window.onProgress(progress);
+        };
+    }
+    await store.waitLoading();
+    return await store.toPDFDataURL(attrs);
+};
+const recipeToBlob = async (json, attrs) => {
+    store.loadJSON(json);
+    await store.waitLoading();
+    return await store.toBlob(attrs);
+};
+const recipeToGIFDataURL = async (json, attrs) => {
+    store.loadJSON(json);
+    return await store.toGIFDataURL(attrs);
+};
+export const jsonToDataURL = async (page, json, attrs) => {
+    return await page.evaluate(recipeToDataURL, json, attrs || {});
+};
+export const jsonToPDFDataURL = async (page, json, attrs) => {
+    return page.evaluate(recipeToPDFDataURL, json, attrs || {});
+};
+export const jsonToBlob = async (page, json, attrs) => {
+    return page.evaluate(recipeToBlob, json, attrs || {});
+};
+// Render options that map directly to a `window.config.*` setter on the client.
+// `arg: "value"` passes the option value through whenever it is explicitly set
+// (including `false`, so a client-side default can be turned off). `arg: true`
+// is an enable-only flag: the setter is called with `true` only when the option
+// is truthy (passing `false` is a no-op, leaving the client default in place).
+const CONFIG_OPTION_SETTERS = [
+    { option: "assetLoadTimeout", method: "setAssetLoadTimeout", arg: "value" },
+    { option: "fontLoadTimeout", method: "setFontLoadTimeout", arg: "value" },
+    { option: "legacyRichTextEnabled", method: "setLegacyRichTextEnabled", arg: true },
+    { option: "textVerticalResizeEnabled", method: "setTextVerticalResizeEnabled", arg: "value" },
+    { option: "textSplitAllowed", method: "unstable_setTextSplitAllowed", arg: true },
+    { option: "textOverflow", method: "setTextOverflow", arg: "value" },
+];
+// Apply the option→config setters above to a page in a single round-trip.
+const applyConfigOptions = async (page, attrs = {}) => {
+    const calls = [];
+    for (const { option, method, arg } of CONFIG_OPTION_SETTERS) {
+        if (arg === "value") {
+            // value passthrough — apply on any explicit value, including `false`
+            if (attrs[option] !== undefined)
+                calls.push({ method, value: attrs[option] });
+        }
+        else if (attrs[option]) {
+            // enable-only flag
+            calls.push({ method, value: arg });
+        }
+    }
+    if (calls.length === 0)
+        return;
+    await page.evaluate((calls) => {
+        for (const { method, value } of calls) {
+            if (window.config && window.config[method]) {
+                window.config[method](value);
+            }
+            else {
+                console.error(`${method} function is not defined in the client.`);
+            }
+        }
+    }, calls);
+};
+const busyPages = [];
+const createdInstances = [];
+export const createInstance = async ({ key, url, useParallelPages = true, browser, requestInterceptor, useFontCache = true, } = {}) => {
+    const visitPage = url || `${DEFAULT_CLIENT}?key=${key}`;
+    const hasCustomClientUrl = Boolean(url);
+    const firstPage = useParallelPages
+        ? null
+        : await createPage(browser, visitPage, requestInterceptor, useFontCache);
+    async function ensureAssetErrorHelpers(page) {
+        await page.evaluate(() => {
+            // Define helpers once per page. They unify asset-loading error handling
+            // across all exports (dataURL/image/pdf/video).
+            if (!window.__polotnoConsumeAssetError) {
+                window.__polotnoConsumeAssetError = (attrs) => {
+                    const error = window._polotnoError;
+                    if (!error)
+                        return null;
+                    // Clear immediately to avoid double-reporting.
+                    window._polotnoError = null;
+                    const message = String(error);
+                    // Cross-package contract: every font-load error from polotno core
+                    // references the family as `font "<name>"` (e.g. `Timeout for
+                    // loading font "X"`, `Font "X" not found: ...`). Match that stable
+                    // marker rather than any one full sentence.
+                    const isFontError = /font\s+"/i.test(message);
+                    const skipFontError = isFontError && attrs && attrs.skipFontError;
+                    const isImageError = message.indexOf("image ") >= 0;
+                    const skipImageError = isImageError && attrs && attrs.skipImageError;
+                    if (skipFontError || skipImageError) {
+                        return null;
+                    }
+                    return message;
+                };
+            }
+            if (!window.__polotnoThrowAssetErrorIfAny) {
+                window.__polotnoThrowAssetErrorIfAny = (attrs) => {
+                    const message = window.__polotnoConsumeAssetError(attrs);
+                    if (message) {
+                        throw new Error(message);
+                    }
+                };
+            }
+        });
+    }
+    async function consumeAssetLoadingErrorMessage(page, attrs) {
+        try {
+            return await page.evaluate((attrs) => {
+                if (window.__polotnoConsumeAssetError) {
+                    return window.__polotnoConsumeAssetError(attrs);
+                }
+                return null;
+            }, attrs);
+        }
+        catch (e) {
+            // If the page is already crashed/unavailable, we can't inspect the error.
+            return null;
+        }
+    }
+    const run = async (func, ...args) => {
+        const page = useParallelPages
+            ? await createPage(browser, visitPage, requestInterceptor, useFontCache)
+            : firstPage;
+        if (busyPages.indexOf(page) >= 0) {
+            throw new Error("Current rendering context is busy with another task. Please use `useParallelPages: true` option to run multiple tasks in parallel or make sure previous task is finished before starting a new one.");
+        }
+        busyPages.push(page);
+        // Setup profiling if profilePath is provided
+        let cdpSession = null;
+        const profilePath = args[1]?.profilePath;
+        if (profilePath) {
+            cdpSession = await page.target().createCDPSession();
+            await cdpSession.send("Profiler.enable");
+            await cdpSession.send("Profiler.start");
+        }
+        try {
+            // All direct `window.config.*` setters are applied from one table.
+            await applyConfigOptions(page, args[1]);
+            if (args[1]?.onProgress) {
+                const originalProgress = args[1].onProgress;
+                await page.exposeFunction("onProgress", async (progress, frameTime) => {
+                    originalProgress(progress, frameTime);
+                });
+            }
+            // Allow exposing custom functions (used for chunked data transfer)
+            if (args[1]?.exposeFunctions) {
+                for (const [name, fn] of Object.entries(args[1].exposeFunctions)) {
+                    await page.exposeFunction(name, fn);
+                }
+            }
+            await page.evaluate(() => {
+                if (window.config?.onLoadError) {
+                    window.config.onLoadError((error) => {
+                        window._polotnoError = error;
+                    });
+                }
+                else {
+                    console.error("onLoadError function is not defined in the client. Error handling will not work.");
+                }
+            });
+            await ensureAssetErrorHelpers(page);
+            const result = await page.evaluate(func, ...args);
+            // Stop profiler and save profile if enabled
+            if (cdpSession && profilePath) {
+                const { profile } = await cdpSession.send("Profiler.stop");
+                fs.writeFileSync(profilePath, JSON.stringify(profile));
+                console.log(`CPU profile saved to: ${profilePath}`);
+            }
+            const assetErrorMessage = await consumeAssetLoadingErrorMessage(page, args[1]);
+            if (assetErrorMessage) {
+                throw new Error(assetErrorMessage);
+            }
+            // remove busy page
+            busyPages.splice(busyPages.indexOf(page), 1);
+            if (useParallelPages) {
+                await page.close();
+            }
+            return result;
+        }
+        catch (e) {
+            // Stop profiler and save profile even on error
+            if (cdpSession && profilePath) {
+                console.log("saving profile");
+                try {
+                    const { profile } = await cdpSession.send("Profiler.stop");
+                    fs.writeFileSync(profilePath, JSON.stringify(profile));
+                    console.log(`CPU profile saved to: ${profilePath}`);
+                }
+                catch (profileError) {
+                    console.error("Failed to save profile:", profileError.message);
+                }
+            }
+            // If `page.evaluate()` failed (e.g. thrown during onProgress), still prefer
+            // a captured Polotno asset-loading error when available.
+            const assetErrorMessage = await consumeAssetLoadingErrorMessage(page, args[1]);
+            // remove busy page
+            busyPages.splice(busyPages.indexOf(page), 1);
+            if (useParallelPages) {
+                await page.close();
+            }
+            if (assetErrorMessage) {
+                throw new Error(assetErrorMessage);
+            }
+            throw e;
+        }
+    };
+    // Pre-flight schema check: catch malformed JSON before launching the browser
+    // and throw `Invalid Polotno design: …`. `assertValidDesign` mirrors the core
+    // store's tolerance (it coerces `null` to defaults like the store does, rather
+    // than rejecting input the store would happily render), so this only throws on
+    // genuinely malformed JSON.
+    const assertValidJson = (json) => {
+        assertValidDesign(json, { mode: "partial" });
+    };
+    const jsonToDataURL = async (json, attrs) => {
+        await assertValidJson(json);
+        return await run(recipeToDataURL, json, attrs || {});
+    };
+    const jsonToGIFDataURL = async (json, attrs) => {
+        await assertValidJson(json);
+        return await run(recipeToGIFDataURL, json, attrs || {});
+    };
+    const jsonToGIFBase64 = async (json, attrs) => {
+        const url = await jsonToGIFDataURL(json, attrs);
+        return url.split("base64,")[1];
+    };
+    const jsonToImageBase64 = async (json, attrs) => {
+        const url = await jsonToDataURL(json, attrs);
+        return url.split("base64,")[1];
+    };
+    const jsonToPDFDataURL = async (json, attrs) => {
+        await assertValidJson(json);
+        return await run(recipeToPDFDataURL, json, attrs || {});
+    };
+    const jsonToPDFBase64 = async (json, attrs) => {
+        const url = await jsonToPDFDataURL(json, attrs);
+        return url.split("base64,")[1];
+    };
+    const jsonToBlob = async (json, attrs) => {
+        const base64 = await jsonToImageBase64(json, attrs);
+        const blob = Buffer.from(base64, "base64");
+        return blob;
+    };
+    const jsonToVideoFile = async (json, outputPath, attrs = {}) => {
+        await assertValidJson(json);
+        const shouldDownloadMedia = !hasCustomClientUrl && !(attrs && attrs.skipDownloads);
+        const prepared = shouldDownloadMedia
+            ? await prepareLocalMediaForVideoExport(json)
+            : { json, cleanup: async () => { } };
+        const writeStream = fs.createWriteStream(outputPath);
+        try {
+            const mimeType = await run(async (json, attrs) => {
+                const pixelRatio = attrs.pixelRatio || 1;
+                store.loadJSON(json);
+                window.__polotnoThrowAssetErrorIfAny(attrs);
+                // keep store internals consistent with image/pdf exports
+                store.setElementsPixelRatio(pixelRatio);
+                // loop through all pages and wait for loading for all layout calculations
+                // (this helps stabilize text/layout across multi-page designs)
+                for (const page of store.pages) {
+                    store.selectPage(page.id);
+                    await store.waitLoading();
+                    window.__polotnoThrowAssetErrorIfAny(attrs);
+                }
+                if (store.pages.length > 0) {
+                    store.selectPage(store.pages[0].id);
+                    await store.waitLoading();
+                    window.__polotnoThrowAssetErrorIfAny(attrs);
+                }
+                // For video export, we always use 'resize' text overflow mode
+                // to ensure text fits properly in animations. User preferences are ignored for now.
+                window.config.setTextOverflow("resize");
+                if (!window.__polotnoLoadVideoExport) {
+                    throw new Error("Video export module loader is not defined in the client. Expected window.__polotnoLoadVideoExport().");
+                }
+                const { storeToVideo } = await window.__polotnoLoadVideoExport();
+                // Create abort controller to cancel video render on error
+                const abortController = new AbortController();
+                let capturedError = null;
+                // Always have an internal progress callback to check for errors,
+                // even if user didn't provide onProgress
+                const progressCallback = (progress, frameTime) => {
+                    // Check for asset-loading errors during render (without throwing)
+                    const errorMessage = window.__polotnoConsumeAssetError(attrs);
+                    if (errorMessage) {
+                        capturedError = errorMessage;
+                        abortController.abort();
+                        return;
+                    }
+                    // Call user's progress callback if provided
+                    if (window.onProgress) {
+                        window.onProgress(progress, frameTime);
+                    }
+                };
+                let videoBlob;
+                try {
+                    videoBlob = await storeToVideo({
+                        store,
+                        fps: attrs.fps,
+                        pixelRatio,
+                        onProgress: progressCallback,
+                        signal: abortController.signal,
+                    });
+                }
+                catch (e) {
+                    // If we aborted due to asset error, throw that instead
+                    if (capturedError) {
+                        throw new Error(capturedError);
+                    }
+                    throw e;
+                }
+                // Final check for any errors that occurred
+                if (capturedError) {
+                    throw new Error(capturedError);
+                }
+                // Stream blob in chunks via exposed function to avoid large payload issues.
+                // CRITICAL (!!!): Chunk size MUST be a multiple of 3 bytes because base64 encodes
+                // 3 bytes -> 4 characters. If chunks aren't aligned, each chunk gets padding
+                // (= or ==) at the end, and joining them creates invalid base64 and video may corrupt.
+                const CHUNK_SIZE = 3 * 1024 * 1024; // 3MB, divisible by 3
+                const arrayBuffer = await videoBlob.arrayBuffer();
+                const uint8Array = new Uint8Array(arrayBuffer);
+                for (let offset = 0; offset < uint8Array.length; offset += CHUNK_SIZE) {
+                    const end = Math.min(offset + CHUNK_SIZE, uint8Array.length);
+                    const chunk = uint8Array.slice(offset, end);
+                    let binary = "";
+                    for (let i = 0; i < chunk.length; i++) {
+                        binary += String.fromCharCode(chunk[i]);
+                    }
+                    await window.__polotnoWriteChunk(btoa(binary));
+                }
+                return videoBlob.type;
+            }, prepared.json, {
+                ...attrs,
+                exposeFunctions: {
+                    __polotnoWriteChunk: (base64Chunk) => {
+                        const buffer = Buffer.from(base64Chunk, "base64");
+                        writeStream.write(buffer);
+                    },
+                },
+            });
+            writeStream.end();
+            await new Promise((resolve) => writeStream.on("finish", resolve));
+            // Convert audio to AAC if needed
+            if (isFfmpegAvailable()) {
+                const codec = getAudioCodec(outputPath);
+                if (codec && codec !== "aac") {
+                    const tempPath = outputPath + ".tmp.mp4";
+                    convertAudioToAac(outputPath, tempPath);
+                    await fs.promises.rename(tempPath, outputPath);
+                }
+            }
+            return mimeType;
+        }
+        finally {
+            await prepared.cleanup();
+        }
+    };
+    const jsonToVideoDataURL = async (json, attrs) => {
+        const tempPath = path.join(os.tmpdir(), `polotno-video-${Date.now()}-${Math.random().toString(36).slice(2)}.mp4`);
+        try {
+            const mimeType = await jsonToVideoFile(json, tempPath, attrs);
+            const buffer = await fs.promises.readFile(tempPath);
+            return `data:${mimeType || "video/mp4"};base64,${buffer.toString("base64")}`;
+        }
+        finally {
+            await fs.promises.rm(tempPath, { force: true });
+        }
+    };
+    const jsonToVideoBase64 = async (json, attrs) => {
+        const tempPath = path.join(os.tmpdir(), `polotno-video-${Date.now()}-${Math.random().toString(36).slice(2)}.mp4`);
+        try {
+            await jsonToVideoFile(json, tempPath, attrs);
+            const buffer = await fs.promises.readFile(tempPath);
+            return buffer.toString("base64");
+        }
+        finally {
+            await fs.promises.rm(tempPath, { force: true });
+        }
+    };
+    const instance = {
+        close: async () => {
+            createdInstances.splice(createdInstances.indexOf(instance), 1);
+            await browser.close();
+        },
+        firstPage,
+        browser,
+        run,
+        jsonToDataURL,
+        jsonToImageBase64,
+        jsonToPDFDataURL,
+        jsonToPDFBase64,
+        jsonToBlob,
+        jsonToGIFDataURL,
+        jsonToGIFBase64,
+        jsonToVideoDataURL,
+        jsonToVideoBase64,
+        jsonToVideoFile,
+        createPage: async () => await createPage(browser, visitPage, requestInterceptor, useFontCache),
+    };
+    createdInstances.push(instance);
+    return instance;
+};
+// Function to close all created instances in parallel
+const closeAllInstances = async () => {
+    await Promise.all(createdInstances.map((instance) => instance.close()));
+};
+// Also handle other termination signals
+["SIGINT", "SIGTERM", "SIGQUIT", "exit"].forEach((signal) => {
+    process.on(signal, () => {
+        closeAllInstances();
+    });
+});