@seedprotocol/sdk 0.4.31 → 0.5.1

package/dist/FileManager-5GkHtxF7.js

@@ -1,1256 +0,0 @@
-import { p as BaseDb, a1 as appState, v as BaseFileManager } from './index-BcXKZQpX.js';
-import debug from 'debug';
-import 'xstate';
-import 'drizzle-orm/sqlite-core';
-import 'drizzle-orm';
-import 'nanoid';
-import 'nanoid-dictionary';
-import 'ethers';
-import 'pluralize';
-import '@sinclair/typebox';
-import 'drizzle-orm/casing';
-import 'lodash-es';
-import 'rxjs';
-import 'arweave';
-import 'js-sha3';
-
-const saveAppState = async (key, value) => {
-    const appDb = BaseDb.getAppDb();
-    await appDb
-        .insert(appState)
-        .values({
-        key,
-        value,
-    })
-        .onConflictDoUpdate({
-        target: appState.key,
-        set: {
-            value,
-        },
-    });
-};
-
-var filesDownload = `(
-  ${function () {
-    const identifyString = (str) => {
-        try {
-            JSON.parse(str);
-            return 'json';
-        }
-        catch (e) {
-            // Not JSON
-        }
-        if (!str) {
-            return;
-        }
-        if (str.trim().startsWith('<') && str.trim().endsWith('>')) {
-            return 'html';
-        }
-        // Simple markdown checks (very naive)
-        if (/^#{1,6}\s|^-{3,}|\*{3,}|^-{1,2}\s|\*\s/.test(str)) {
-            return 'markdown';
-        }
-        if (/^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/.test(str)) {
-            return 'base64';
-        }
-        // Default to plain text if unsure
-        return 'text';
-    };
-    const getMimeType = (base64) => {
-        if (!base64) {
-            return null;
-        }
-        const result = base64.match(/^data:([a-zA-Z0-9]+\/[a-zA-Z0-9-.+]+).*,/);
-        if (result && result.length > 1) {
-            return result[1];
-        }
-        else {
-            return null; // MIME type could not be determined
-        }
-    };
-    const getDataTypeFromString = (data) => {
-        const nonImageBase64Regex = /^(?!data:image\/(?:jpeg|png|gif|bmp|webp);base64,)[A-Za-z0-9+/=]+$/;
-        if (nonImageBase64Regex.test(data)) {
-            return 'base64';
-        }
-        // Regular expression for base64 (simple version, checking for base64 format)
-        const imageBase64Regex = /^data:image\/[a-zA-Z]+;base64,[A-Za-z0-9+/]+={0,2}$/;
-        if (imageBase64Regex.test(data)) {
-            return 'imageBase64';
-        }
-        // Regular expression for URL (simple version, checking for common URL format)
-        const urlRegex = /^(http:\/\/www\.|https:\/\/www\.|http:\/\/|https:\/\/)?[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$/;
-        if (urlRegex.test(data)) {
-            return 'url';
-        }
-        return null;
-    };
-    const isBinary = (arrayBuffer) => {
-        const view = new Uint8Array(arrayBuffer);
-        let nonTextCount = 0;
-        const threshold = 0.2; // Adjust as needed (e.g., 20% non-text implies binary)
-        for (let i = 0; i < view.length; i++) {
-            const byte = view[i];
-            // ASCII printable characters (32-126) and common whitespace (9, 10, 13)
-            if ((byte >= 32 && byte <= 126) || // Printable ASCII
-                byte === 9 || byte === 10 || byte === 13 // Tab, LF, CR
-            ) {
-                continue;
-            }
-            nonTextCount++;
-            if (nonTextCount / view.length > threshold) {
-                return true; // More than threshold are non-text bytes
-            }
-        }
-        return false; // Fewer than threshold are non-text bytes
-    };
-    const saveBufferToOPFS = async (filePath, buffer) => {
-        // Access the OPFS root directory
-        const rootHandle = await navigator.storage.getDirectory();
-        // Split the filePath into directory segments and file name
-        const segments = filePath.split('/').filter(Boolean);
-        const fileName = segments.pop(); // Extract the file name
-        if (!fileName) {
-            throw new Error('Invalid file path: No file name provided.');
-        }
-        // Traverse or create directories as needed
-        let currentDirHandle = rootHandle;
-        for (const segment of segments) {
-            currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
-        }
-        // Create or open the file in OPFS
-        const fileHandleAsync = await currentDirHandle.getFileHandle(fileName, { create: true });
-        const fileHandle = await fileHandleAsync.createSyncAccessHandle();
-        // Write the buffer to the file
-        fileHandle.write(buffer);
-        fileHandle.flush();
-        fileHandle.close();
-    };
-    const getFilesPath = (filesRoot, ...parts) => {
-        const root = filesRoot.replace(/\/$/, '');
-        return [root, ...parts].filter(Boolean).join('/').replace(/\/+/g, '/');
-    };
-    const downloadFiles = async ({ transactionIds, arweaveHost, filesRoot = '/files', }) => {
-        let arrayBuffer;
-        for (const transactionId of transactionIds) {
-            try {
-                const response = await fetch(`https://${arweaveHost}/raw/${transactionId}`);
-                arrayBuffer = await response.arrayBuffer();
-            }
-            catch (error) {
-                globalThis.postMessage({
-                    message: 'excludeTransaction',
-                    transactionId,
-                });
-                continue;
-            }
-            let dataString;
-            const isBinaryData = isBinary(arrayBuffer);
-            if (!isBinaryData) {
-                const decoder = new TextDecoder('utf-8');
-                const text = decoder.decode(arrayBuffer);
-                dataString = text;
-            }
-            if (dataString && dataString.startsWith('===FILE_SEPARATOR===')) {
-                const dataStringParts = dataString
-                    .split('===FILE_SEPARATOR===')
-                    .slice(1);
-                if (dataStringParts.length % 2 !== 0) {
-                    throw new Error('Input array must have an even number of elements.');
-                }
-                for (let i = 0; i < dataStringParts.length; i += 2) {
-                    const contentType = dataStringParts[i];
-                    const content = dataStringParts[i + 1];
-                    const encoder = new TextEncoder();
-                    if (contentType === 'html') {
-                        const fileName = `${transactionId}.html`;
-                        const buffer = encoder.encode(content);
-                        saveBufferToOPFS(getFilesPath(filesRoot, 'html', fileName), buffer);
-                    }
-                    if (contentType === 'json') {
-                        const fileName = `${transactionId}.json`;
-                        const buffer = encoder.encode(content);
-                        saveBufferToOPFS(getFilesPath(filesRoot, 'json', fileName), buffer);
-                    }
-                }
-                continue;
-            }
-            if (!dataString && arrayBuffer) {
-                saveBufferToOPFS(getFilesPath(filesRoot, 'images', transactionId), new Uint8Array(arrayBuffer));
-                continue;
-            }
-            if (!dataString) {
-                continue;
-            }
-            let contentType = identifyString(dataString);
-            if (contentType !== 'json' &&
-                contentType !== 'base64' &&
-                contentType !== 'html') {
-                const possibleImageType = getDataTypeFromString(dataString);
-                if (!possibleImageType) {
-                    continue;
-                }
-                contentType = possibleImageType;
-            }
-            if (contentType === 'url') {
-                const url = dataString;
-                let buffer;
-                try {
-                    const response = await fetch(url);
-                    buffer = await response.arrayBuffer();
-                }
-                catch (error) {
-                    globalThis.postMessage({
-                        message: 'excludeTransaction',
-                        transactionId,
-                    });
-                    continue;
-                }
-                const bufferUint8Array = new Uint8Array(buffer);
-                // Extract the file extension from the URL
-                const extensionMatch = url.match(/\.(jpg|jpeg|png|gif|bmp|webp|svg)$/i);
-                if (!extensionMatch) {
-                    throw new Error('Unable to determine the file extension from the URL.');
-                }
-                extensionMatch[0]; // e.g., ".jpg"
-                // Set the file name (you can customize this)
-                // const fileNameFromUrl = `${transactionId}${fileExtension}`
-                await saveBufferToOPFS(getFilesPath(filesRoot, 'images', transactionId), bufferUint8Array);
-                continue;
-            }
-            const mimeType = getMimeType(dataString);
-            let fileExtension = mimeType;
-            if (fileExtension && fileExtension?.startsWith('image')) {
-                fileExtension = fileExtension.replace('image/', '');
-            }
-            let fileName = transactionId;
-            if (contentType === 'base64') {
-                if (fileExtension) {
-                    fileName += `.${fileExtension}`;
-                }
-                // Remove the Base64 header if it exists (e.g., "data:image/png;base64,")
-                const base64Data = dataString.split(',').pop() || '';
-                // Decode the Base64 string to binary
-                const binaryString = atob(base64Data);
-                const length = binaryString.length;
-                const binaryData = new Uint8Array(length);
-                for (let i = 0; i < length; i++) {
-                    binaryData[i] = binaryString.charCodeAt(i);
-                }
-                await saveBufferToOPFS(getFilesPath(filesRoot, 'images', fileName), binaryData);
-            }
-            if (contentType === 'html') {
-                fileName += '.html';
-                const encoder = new TextEncoder();
-                const buffer = encoder.encode(dataString);
-                await saveBufferToOPFS(getFilesPath(filesRoot, 'html', fileName), buffer);
-            }
-            if (contentType === 'json') {
-                fileName += '.json';
-                const encoder = new TextEncoder();
-                const buffer = encoder.encode(dataString);
-                await saveBufferToOPFS(getFilesPath(filesRoot, 'json', fileName), buffer);
-            }
-        }
-    };
-    onmessage = async (e) => {
-        const { debug, filesRoot } = e.data;
-        if (!debug) {
-            console.log = () => { };
-        }
-        await downloadFiles({ ...e.data, filesRoot });
-        globalThis.postMessage({
-            message: 'filesDownload onmessage done',
-            done: true,
-        });
-    };
-}.toString()}
-)()`;
-
-const logger$2 = debug('seedSdk:browser:workers:FileDownloader');
-class FileDownloader {
-    constructor() {
-        this.workersArchive = [];
-        this.downloadAll = async ({ transactionIds, arweaveHost, excludedTransactions }) => {
-            if (this.workersArchive.length > 0) {
-                for (let i = 0; i < this.workersArchive.length; i++) {
-                    this.workersArchive[i].terminate();
-                    delete this.workersArchive[i];
-                }
-                this.workersArchive = [];
-            }
-            const worker = new Worker(this.workerBlobUrl);
-            this.workersArchive.push(worker);
-            const localExcludedTransactions = new Set(excludedTransactions);
-            return new Promise((resolve, reject) => {
-                worker.onmessage = (e) => {
-                    logger$2('filesDownload main thread onmessage', e.data);
-                    if (e.data.message === 'excludeTransaction') {
-                        localExcludedTransactions.add(e.data.transactionId);
-                    }
-                    if (e.data.done) {
-                        saveAppState('excludedTransactions', JSON.stringify(Array.from(localExcludedTransactions)))
-                            .then(() => {
-                            resolve(e.data);
-                        })
-                            .catch((error) => {
-                            reject(error);
-                        });
-                    }
-                    if (e.data.error) {
-                        reject(e.data.error);
-                    }
-                };
-                worker.postMessage({
-                    transactionIds,
-                    arweaveHost,
-                    debug: logger$2.enabled,
-                    filesRoot: BaseFileManager.getWorkingDir(),
-                });
-            });
-        };
-        this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
-        this.workerBlobUrl = globalThis.URL.createObjectURL(new Blob([filesDownload], { type: 'application/javascript' }));
-    }
-}
-
-var imageResize = `(
-  ${function () {
-    async function listFilesInDirectory(directoryHandle) {
-        const entries = [];
-        for await (const [name, handle] of directoryHandle.entries()) {
-            entries.push({
-                name,
-                kind: handle.kind,
-            });
-        }
-        return entries;
-    }
-    const getFileHandle = async (path, rootHandle = null) => {
-        // Split the path into segments
-        const segments = path.split('/').filter(Boolean);
-        // Start from the root directory if not provided
-        if (!rootHandle) {
-            rootHandle = await navigator.storage.getDirectory();
-        }
-        let currentHandle = rootHandle;
-        // Traverse the path segments
-        for (let i = 0; i < segments.length; i++) {
-            const segment = segments[i];
-            const isLastSegment = i === segments.length - 1;
-            try {
-                for await (const [name, handle] of currentHandle.entries()) {
-                    if (name !== segment) {
-                        continue;
-                    }
-                    if (isLastSegment) {
-                        if (handle.kind === 'file') {
-                            return handle; // Return the file handle if found
-                        }
-                        else {
-                            throw new Error(`Path '${path}' refers to a directory, not a file.`);
-                        }
-                    }
-                    else if (handle.kind === 'directory') {
-                        currentHandle = handle; // Traverse into the directory
-                    }
-                    else {
-                        throw new Error(`Invalid path segment '${segment}'`);
-                    }
-                }
-            }
-            catch (err) {
-                if (err instanceof Error && err.name === 'NotFoundError') {
-                    throw new Error(`Path '${path}' does not exist.`);
-                }
-                else {
-                    throw err;
-                }
-            }
-        }
-        throw new Error(`Path '${path}' could not be resolved.`);
-    };
-    async function getFileFromOPFS(path) {
-        const fileHandleAsync = await getFileHandle(path);
-        const file = await fileHandleAsync.getFile();
-        return file;
-    }
-    /** Infer MIME from magic bytes. OPFS File may have empty type, causing createImageBitmap to fail. */
-    async function getBlobWithInferredMime(file) {
-        const buf = await file.arrayBuffer();
-        const bytes = new Uint8Array(buf);
-        let mime = file.type;
-        if (!mime || mime === '') {
-            if (bytes[0] === 0xff && bytes[1] === 0xd8)
-                mime = 'image/jpeg';
-            else if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)
-                mime = 'image/png';
-            else if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x52 && bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50)
-                mime = 'image/webp';
-            else if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46)
-                mime = 'image/gif';
-            else if (bytes[0] === 0x42 && bytes[1] === 0x4d)
-                mime = 'image/bmp';
-            else if (bytes[4] === 0x66 && bytes[5] === 0x74 && bytes[6] === 0x79 && bytes[7] === 0x70 && bytes[8] === 0x61 && bytes[9] === 0x76 && bytes[10] === 0x69 && bytes[11] === 0x66)
-                mime = 'image/avif';
-            else if (bytes[4] === 0x66 && bytes[5] === 0x74 && bytes[6] === 0x79 && bytes[7] === 0x70 && bytes[8] === 0x68 && bytes[9] === 0x65 && bytes[10] === 0x69 && bytes[11] === 0x63)
-                mime = 'image/heic';
-            else
-                mime = 'image/jpeg';
-        }
-        return new Blob([buf], { type: mime });
-    }
-    const DEFAULT_CONFIG = {
-        argorithm: 'null',
-        processByHalf: true,
-        quality: 0.5,
-        maxWidth: 800,
-        maxHeight: 600,
-        debug: false,
-        mimeType: 'image/jpeg',
-    };
-    function isIos() {
-        if (typeof navigator === 'undefined')
-            return false;
-        if (!navigator.userAgent)
-            return false;
-        return /iPad|iPhone|iPod/.test(navigator.userAgent);
-    }
-    const getTargetHeight = (srcHeight, scale, config) => {
-        return Math.min(Math.floor(srcHeight * scale), config.maxHeight);
-    };
-    const findMaxWidth = (config, canvas) => {
-        //Let's find the max available width for scaled image
-        const ratio = canvas.width / canvas.height;
-        let mWidth = Math.min(canvas.width, config.maxWidth, ratio * config.maxHeight);
-        if (config.maxSize &&
-            config.maxSize > 0 &&
-            config.maxSize < (canvas.width * canvas.height) / 1000)
-            mWidth = Math.min(mWidth, Math.floor((config.maxSize * 1000) / canvas.height));
-        if (!!config.scaleRatio)
-            mWidth = Math.min(mWidth, Math.floor(config.scaleRatio * canvas.width));
-        const rHeight = getTargetHeight(canvas.height, mWidth / canvas.width, config);
-        // console.log(
-        //   'browser-image-resizer: original image size = ' +
-        //   canvas.width +
-        //   ' px (width) X ' +
-        //   canvas.height +
-        //   ' px (height)'
-        // );
-        // console.log(
-        //   'browser-image-resizer: scaled image size = ' +
-        //   mWidth +
-        //   ' px (width) X ' +
-        //   rHeight +
-        //   ' px (height)'
-        // );
-        if (mWidth <= 0) {
-            mWidth = 1;
-            console.warn("browser-image-resizer: image size is too small");
-        }
-        if (isIos() && mWidth * rHeight > 167777216) {
-            console.error("browser-image-resizer: image size is too large for iOS WebKit.", mWidth, rHeight);
-            throw new Error("browser-image-resizer: image size is too large for iOS WebKit.");
-        }
-        return mWidth;
-    };
-    /**
-    * Hermite resize, multicore version - fast image resize/resample using Hermite filter.
-    */
-    const resample = (srcCanvas, destCanvas, config) => {
-        return new Promise((resolve, reject) => {
-            const ratio_h = srcCanvas.height / destCanvas.height;
-            const cores = Math.min(navigator.hardwareConcurrency || 4, 4);
-            //prepare source and target data for workers
-            const ctx = srcCanvas.getContext('2d');
-            if (!ctx)
-                return reject('Canvas is empty (resample)');
-            const data_part = [];
-            const block_height = Math.ceil(srcCanvas.height / cores / 2) * 2;
-            let end_y = -1;
-            for (let c = 0; c < cores; c++) {
-                //source
-                const offset_y = end_y + 1;
-                if (offset_y >= srcCanvas.height) {
-                    //size too small, nothing left for this core
-                    continue;
-                }
-                end_y = Math.min(offset_y + block_height - 1, srcCanvas.height - 1);
-                const current_block_height = Math.min(block_height, srcCanvas.height - offset_y);
-                data_part.push({
-                    source: ctx.getImageData(0, offset_y, srcCanvas.width, block_height),
-                    startY: Math.ceil(offset_y / ratio_h),
-                    height: current_block_height
-                });
-            }
-            //start
-            const destCtx = destCanvas.getContext('2d');
-            if (!destCtx)
-                return reject('Canvas is empty (resample dest)');
-            for (let c = 0; c < data_part.length; c++) {
-                //draw
-                const height_part = Math.ceil(data_part[c].height / ratio_h);
-                const target = destCtx.createImageData(destCanvas.width, height_part);
-                // target.data.set(event.data.target);
-                destCtx.putImageData(target, 0, data_part[c].startY);
-            }
-        });
-    };
-    /**
-     * Hermite resize - fast image resize/resample using Hermite filter. 1 cpu version!
-     */
-    const resampleSingle = (srcCanvasData, destCanvasData) => {
-        const ratio_w = srcCanvasData.width / destCanvasData.width;
-        const ratio_h = srcCanvasData.height / destCanvasData.height;
-        const ratio_w_half = Math.ceil(ratio_w / 2);
-        const ratio_h_half = Math.ceil(ratio_h / 2);
-        const data = srcCanvasData.data;
-        const data2 = destCanvasData.data;
-        for (let j = 0; j < destCanvasData.height; j++) {
-            for (let i = 0; i < destCanvasData.width; i++) {
-                const x2 = (i + j * destCanvasData.width) * 4;
-                let weight = 0;
-                let weights = 0;
-                let weights_alpha = 0;
-                let gx_r = 0;
-                let gx_g = 0;
-                let gx_b = 0;
-                let gx_a = 0;
-                const center_y = j * ratio_h;
-                const xx_start = Math.floor(i * ratio_w);
-                const xx_stop = Math.min(Math.ceil((i + 1) * ratio_w), srcCanvasData.width);
-                const yy_start = Math.floor(j * ratio_h);
-                const yy_stop = Math.min(Math.ceil((j + 1) * ratio_h), srcCanvasData.height);
-                for (let yy = yy_start; yy < yy_stop; yy++) {
-                    let dy = Math.abs(center_y - yy) / ratio_h_half;
-                    let center_x = i * ratio_w;
-                    let w0 = dy * dy; //pre-calc part of w
-                    for (let xx = xx_start; xx < xx_stop; xx++) {
-                        let dx = Math.abs(center_x - xx) / ratio_w_half;
-                        let w = Math.sqrt(w0 + dx * dx);
-                        if (w >= 1) {
-                            //pixel too far
-                            continue;
-                        }
-                        //hermite filter
-                        weight = 2 * w * w * w - 3 * w * w + 1;
-                        let pos_x = 4 * (xx + yy * srcCanvasData.width);
-                        //alpha
-                        gx_a += weight * data[pos_x + 3];
-                        weights_alpha += weight;
-                        //colors
-                        if (data[pos_x + 3] < 255)
-                            weight = weight * data[pos_x + 3] / 250;
-                        gx_r += weight * data[pos_x];
-                        gx_g += weight * data[pos_x + 1];
-                        gx_b += weight * data[pos_x + 2];
-                        weights += weight;
-                    }
-                }
-                data2[x2] = gx_r / weights;
-                data2[x2 + 1] = gx_g / weights;
-                data2[x2 + 2] = gx_b / weights;
-                data2[x2 + 3] = gx_a / weights_alpha;
-            }
-        }
-    };
-    /**
-    * Hermite resize. Detect cpu count and use best option for user.
-    */
-    const resampleAuto = (srcCanvas, destCanvas, config) => {
-        if (!!globalThis.Worker && navigator.hardwareConcurrency > 1 && config?.argorithm !== 'hermite_single') {
-            //workers supported and we have at least 2 cpu cores - using multithreading
-            return resample(srcCanvas, destCanvas);
-        }
-        else {
-            //1 cpu version
-            const { srcImgData, destImgData } = getImageData(srcCanvas, destCanvas);
-            resampleSingle(srcImgData, destImgData);
-            destCanvas.getContext('2d').putImageData(destImgData, 0, 0);
-            return;
-        }
-    };
-    async function scaleCanvasWithAlgorithm(canvas, config) {
-        const scale = config.outputWidth / canvas.width;
-        const scaled = new OffscreenCanvas(Math.floor(config.outputWidth), getTargetHeight(canvas.height, scale, config));
-        switch (config.algorithm) {
-            case 'hermite': {
-                await resampleAuto(canvas, scaled, config);
-                break;
-            }
-            case 'hermite_single': {
-                const { srcImgData, destImgData } = getImageData(canvas, scaled);
-                resampleSingle(srcImgData, destImgData);
-                scaled?.getContext('2d')?.putImageData(destImgData, 0, 0);
-                break;
-            }
-            case 'bilinear': {
-                // const { srcImgData, destImgData } = getImageData(canvas, scaled);
-                // bilinear(srcImgData, destImgData, scale);
-                // scaled?.getContext('2d')?.putImageData(destImgData, 0, 0);
-                break;
-            }
-            default: {
-                scaled.getContext('2d')?.drawImage(canvas, 0, 0, scaled.width, scaled.height);
-                break;
-            }
-        }
-        return scaled;
-    }
-    const getHalfScaleCanvas = (src) => {
-        const half = new OffscreenCanvas(src.width / 2, src.height / 2);
-        half
-            ?.getContext('2d')
-            ?.drawImage(src, 0, 0, half.width, half.height);
-        return half;
-    };
-    const getImageData = (canvas, scaled) => {
-        const srcImgData = canvas
-            ?.getContext('2d')
-            ?.getImageData(0, 0, canvas.width, canvas.height);
-        const destImgData = scaled
-            ?.getContext('2d')
-            ?.createImageData(scaled.width, scaled.height);
-        if (!srcImgData || !destImgData)
-            throw Error('Canvas is empty (scaleCanvasWithAlgorithm). You should run this script after the document is ready.');
-        return { srcImgData, destImgData };
-    };
-    async function saveBlobToOPFS(filePath, blob) {
-        // Access the OPFS root directory
-        const rootHandle = await navigator.storage.getDirectory();
-        // Split the filePath into directory segments and file name
-        const segments = filePath.split('/').filter(Boolean);
-        const fileName = segments.pop(); // Extract the file name
-        if (!fileName) {
-            throw new Error('Invalid file path: No file name provided.');
-        }
-        // Traverse or create directories as needed
-        let currentDirHandle = rootHandle;
-        for (const segment of segments) {
-            currentDirHandle = await currentDirHandle.getDirectoryHandle(segment, { create: true });
-        }
-        // Create or open the file in OPFS
-        const fileHandle = await currentDirHandle.getFileHandle(fileName, { create: true });
-        // Write the Blob to the file
-        const writableStream = await fileHandle.createWritable();
-        await writableStream.write(blob);
-        await writableStream.close();
-    }
-    const imageResize = async (filePath, width, height) => {
-        const config = {
-            ...DEFAULT_CONFIG,
-            algorithm: 'hermite_single',
-            mimeType: 'image/webp',
-            maxWidth: width,
-            maxHeight: height,
-        };
-        const rootHandle = await navigator.storage.getDirectory();
-        // List files in the root directory
-        await listFilesInDirectory(rootHandle);
-        const file = await getFileFromOPFS(filePath);
-        const blobWithMime = await getBlobWithInferredMime(file);
-        const imageBitmap = await createImageBitmap(blobWithMime);
-        let converting;
-        if (isIos() && imageBitmap.width * imageBitmap.height > 16777216) {
-            const scale = Math.sqrt(16777216 / (imageBitmap.width * imageBitmap.height));
-            converting = new OffscreenCanvas(Math.floor(imageBitmap.width * scale), Math.floor(imageBitmap.height * scale));
-            converting.getContext('2d')?.drawImage(imageBitmap, 0, 0, converting.width, converting.height);
-        }
-        else {
-            converting = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
-            converting.getContext('2d')?.drawImage(imageBitmap, 0, 0);
-        }
-        const maxWidth = findMaxWidth(config, converting);
-        if (!maxWidth) {
-            throw Error(`browser-image-resizer: maxWidth is ${maxWidth}!!`);
-        }
-        while (config.processByHalf && converting.width >= 2 * maxWidth) {
-            converting = getHalfScaleCanvas(converting);
-        }
-        if (converting.width > maxWidth) {
-            converting = await scaleCanvasWithAlgorithm(converting, Object.assign(config, { outputWidth: maxWidth }));
-        }
-        if (config.mimeType === null) {
-            return converting;
-        }
-        const resizedBlob = await converting.convertToBlob({ type: config.mimeType, quality: config.quality });
-        const pathSegments = filePath.split('/');
-        const fileName = pathSegments.pop();
-        if (!fileName) {
-            throw Error('Invalid file path: No file name provided.');
-        }
-        const newSegments = [
-            ...pathSegments,
-            width,
-        ];
-        const fileNameParts = fileName.split('.');
-        const newFileName = `${fileNameParts[0]}.webp`;
-        const newDirPath = newSegments.join('/');
-        const newFilePath = `${newDirPath}/${newFileName}`;
-        await saveBlobToOPFS(newFilePath, resizedBlob);
-        globalThis.postMessage({
-            done: true,
-            filePath: newFilePath,
-        });
-    };
-    onmessage = async (e) => {
-        const { filePath, width, height, debug } = e.data;
-        if (!debug) {
-            console.log = () => { };
-        }
-        try {
-            await imageResize(filePath, width, height);
-        }
-        catch (err) {
-            globalThis.postMessage({ error: err instanceof Error ? err.message : String(err) });
-        }
-    };
-}.toString()}
-)()`;
-
-const logger$1 = debug('seedSdk:browser:workers:ImageResizer');
-class ImageResizer {
-    constructor() {
-        this.workersArchive = new Map();
-        this.cores = Math.min(navigator.hardwareConcurrency || 4, 4);
-        this.workerBlobUrl = globalThis.URL.createObjectURL(new Blob([imageResize], { type: 'application/javascript' }));
-    }
-    async resize({ filePath, width, height }) {
-        if (this.workersArchive.has(filePath)) {
-            const savedWorker = this.workersArchive.get(filePath);
-            savedWorker?.terminate();
-            logger$1('[ImageResizer.resize] Terminated worker for filePath due to incoming request', filePath);
-            this.workersArchive.delete(filePath);
-        }
-        const worker = new Worker(this.workerBlobUrl);
-        this.workersArchive.set(filePath, worker);
-        return new Promise((resolve, reject) => {
-            worker.onmessage = (e) => {
-                logger$1('[ImageResizer.resize] main thread onmessage', e.data);
-                if (e.data.done) {
-                    const savedWorker = this.workersArchive.get(filePath);
-                    savedWorker?.terminate();
-                    logger$1('[ImageResizer.resize] Terminated worker for filePath due to done', filePath);
-                    this.workersArchive.delete(filePath);
-                    resolve(e.data);
-                }
-                if (e.data.error) {
-                    reject(e.data.error);
-                }
-            };
-            worker.onerror = (err) => {
-                reject(err);
-            };
-            worker.postMessage({
-                filePath,
-                width,
-                height,
-                debug: logger$1.enabled,
-            });
-        });
-    }
-    async resizeAll({ width, height }) {
-        const fs = await BaseFileManager.getFs();
-        const imageDir = BaseFileManager.getFilesPath('images');
-        let imageFilesStats = await fs.promises.readdir(imageDir, {
-            withFileTypes: true
-        });
-        imageFilesStats = imageFilesStats.filter((file) => file.isFile());
-        const imageFiles = imageFilesStats.map((file) => file.path);
-        const widthDir = `${imageDir}/${width}`;
-        await BaseFileManager.createDirIfNotExists(widthDir);
-        for (const imageFile of imageFiles) {
-            const resizedImageExists = await BaseFileManager.pathExists(`${widthDir}/${imageFile}`);
-            if (!resizedImageExists) {
-                await this.resize({ filePath: `${imageDir}/${imageFile}`, width, height });
-            }
-        }
-    }
-}
-
-const logger = debug('seedSdk:browser:helpers:FileManager');
-/**
- * Browser-safe path helpers for SDK virtual file paths.
- * We intentionally avoid Node/CJS path polyfills here to keep browser bundles ESM-safe.
- */
-const pathCompat = {
-    dirname(filePath) {
-        if (!filePath)
-            return '.';
-        const normalized = filePath.replace(/\\/g, '/');
-        if (normalized === '/')
-            return '/';
-        const trimmed = normalized.endsWith('/') && normalized.length > 1
-            ? normalized.slice(0, -1)
-            : normalized;
-        const lastSlash = trimmed.lastIndexOf('/');
-        if (lastSlash === -1)
-            return '.';
-        if (lastSlash === 0)
-            return '/';
-        return trimmed.slice(0, lastSlash);
-    },
-    basename(filePath) {
-        if (!filePath)
-            return '';
-        const normalized = filePath.replace(/\\/g, '/');
-        if (normalized === '/')
-            return '/';
-        const trimmed = normalized.endsWith('/') && normalized.length > 1
-            ? normalized.slice(0, -1)
-            : normalized;
-        const lastSlash = trimmed.lastIndexOf('/');
-        return lastSlash === -1 ? trimmed : trimmed.slice(lastSlash + 1);
-    },
-};
-/** OPFS / ZenFS can throw NotReadableError while a file is still settling after write. */
-function isTransientOpfsReadError(error) {
-    if (error instanceof DOMException && error.name === 'NotReadableError') {
-        return true;
-    }
-    const message = error instanceof Error ? error.message : String(error);
-    // Chromium wording when getFile/read races a writer or stale handle
-    if (message.includes('permission problems') && message.includes('reference')) {
-        return true;
-    }
-    return false;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-class FileManager extends BaseFileManager {
-    static async getFs() {
-        if (!this.zenfsCache) {
-            this.zenfsCache = await import('@zenfs/core');
-        }
-        return this.zenfsCache;
-    }
-    static getFsSync() {
-        if (!this.zenfsCache) {
-            throw new Error('File system not initialized. Call getFs() or initializeFileSystem() first.');
-        }
-        return this.zenfsCache;
-    }
-    static async getContentUrlFromPath(path) {
-        const fileExists = await this.pathExists(path);
-        if (fileExists) {
-            const file = await this.readFile(path);
-            return URL.createObjectURL(file);
-        }
-    }
-    static async initializeFileSystem(workingDir) {
-        const zenfs = await this.getFs();
-        const zenfsDomMod = await import('@zenfs/dom');
-        const { WebAccess } = zenfsDomMod;
-        const { configureSingle } = zenfs;
-        const handle = await navigator.storage.getDirectory();
-        // await configure({
-        //   mounts: {
-        //     '/': {
-        //       backend: WebAccess,
-        //       handle,
-        //     },
-        //   },
-        //   disableUpdateOnRead: true,
-        //   onlySyncOnClose: true,
-        // })
-        await configureSingle({
-            backend: WebAccess,
-            handle,
-        });
-        // Cache is already set in getFs(), so no need to set it again
-    }
-    static async downloadAllFiles({ transactionIds, arweaveHost, excludedTransactions, }) {
-        const fileDownloader = new FileDownloader();
-        await fileDownloader.downloadAll({ transactionIds, arweaveHost, excludedTransactions });
-    }
-    static async resizeImage({ filePath, width, height }) {
-        const imageResizer = new ImageResizer();
-        await imageResizer.resize({ filePath, width, height });
-    }
-    static async resizeAllImages({ width, height }) {
-        const imageResizer = new ImageResizer();
-        await imageResizer.resizeAll({ width, height });
-    }
-    static async listImageFiles() {
-        return this.listFiles('images');
-    }
-    static async listFiles(dir) {
-        const targetDir = BaseFileManager.getFilesPath(dir);
-        const exists = await this.pathExists(targetDir);
-        if (!exists) {
-            return [];
-        }
-        const zenfs = await this.getFs();
-        const entries = await zenfs.promises.readdir(targetDir, { withFileTypes: true });
-        return entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
-    }
-    static async pathExists(filePath) {
-        try {
-            const zenfs = await this.getFs();
-            await zenfs.promises.access(filePath, zenfs.constants.F_OK);
-            return true;
-        }
-        catch (error) {
-            // ENOENT means the file doesn't exist, which is expected
-            if (error?.code === 'ENOENT' || error?.errno === -2) {
-                return false;
-            }
-            // For other errors, re-throw them
-            throw error;
-        }
-    }
-    static async createDirIfNotExists(filePath) {
-        if (!(await this.pathExists(filePath))) {
-            try {
-                const zenfs = await this.getFs();
-                await zenfs.promises.mkdir(filePath, { recursive: true });
-            }
-            catch (error) {
-                // This is a no-op. We tried to create a directory that already exists.
-                logger('Attempted to create a directory that already exists');
-            }
-        }
-    }
-    /**
-     * Waits for a file to exist at the specified path.
-     * @param {string} filePath - The path of the file to check.
-     * @param {number} interval - The interval in milliseconds between checks (default: 500ms).
-     * @param {number} timeout - The timeout in milliseconds to wait for the file to exist (default: 10s).
-     * @returns {Promise<boolean>} - Resolves to true if the file exists within the timeout period, otherwise false.
-     */
-    static async waitForFile(filePath, interval = 1000, timeout = 60000) {
-        // const fs = await this.getFs()
-        // const fsNode = await import('node:fs')
-        const pathExists = await this.pathExists(filePath);
-        if (pathExists) {
-            return true;
-        }
-        return new Promise((resolve, reject) => {
-            const startTime = Date.now();
-            let isBusy = false;
-            const cancelableInterval = new CancelableInterval(async (stop) => {
-                logger('waitForFile', filePath);
-                if (isBusy) {
-                    return;
-                }
-                isBusy = true;
-                // // TODO: Needs to read from OPFS
-                // const exists = await BaseFileManager.pathExists(filePath)
-                // if (exists) {
-                //   stop()
-                //   resolve(true)
-                // }
-                const pathExists = await this.pathExists(filePath);
-                if (pathExists) {
-                    stop();
-                    resolve(true);
-                }
-                if (Date.now() - startTime >= timeout) {
-                    stop();
-                    reject(new Error('Timeout exceeded while waiting for file'));
-                }
-                isBusy = false;
-            }, interval);
-            cancelableInterval.start();
-            // const _interval = setInterval(async () => {
-            //   logger('waitForFile', filePath)
-            //   if (isBusy) {
-            //     return
-            //   }
-            //   isBusy = true
-            //   // TODO: Needs to read from OPFS
-            //   if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
-            //     clearInterval(_interval)
-            //     resolve(true)
-            //   }
-            //   const pathExists = await this.pathExists(filePath)
-            //   if (pathExists) {
-            //     clearInterval(_interval)
-            //     resolve(true)
-            //   }
-            //   if (Date.now() - startTime >= timeout) {
-            //     clearInterval(_interval)
-            //     reject(new Error('Timeout exceeded while waiting for file'))
-            //   }
-            //   isBusy = false
-            // }, interval)
-            // retry(
-            //   {
-            //     times: Math.ceil(timeout / interval),
-            //     interval: interval,
-            //   },
-            //   (callback: Function) => {
-            //     if (fs.existsSync(filePath) && fsNode.existsSync(filePath)) {
-            //       return callback(null, true) // File exists, finish with success
-            //     }
-            //     if (Date.now() - startTime >= timeout) {
-            //       return callback(new Error('Timeout exceeded while waiting for file'))
-            //     }
-            //     callback(new Error('File does not exist yet')) // Retry with this error
-            //   },
-            //   (err: Error, result: boolean) => {
-            //     if (err) {
-            //       return resolve(false) // Resolve as false if timeout or error occurs
-            //     }
-            //     resolve(result) // Resolve as true if file exists
-            //   },
-            // )
-        });
-    }
-    /**
-     * Waits for a file to exist and have content (non-zero size).
-     * This is important for browser/OPFS where writes may not be immediately readable.
-     * @param {string} filePath - The path of the file to check.
-     * @param {number} interval - The interval in milliseconds between checks (default: 100ms).
-     * @param {number} timeout - The timeout in milliseconds to wait (default: 5s).
-     * @returns {Promise<boolean>} - Resolves to true if the file exists with content within the timeout period.
-     */
-    static async waitForFileWithContent(filePath, interval = 100, timeout = 5000) {
-        // First wait for file to exist
-        await this.waitForFile(filePath, interval, timeout);
-        // Now wait for file to have content
-        return new Promise((resolve, reject) => {
-            const startTime = Date.now();
-            let isBusy = false;
-            const cancelableInterval = new CancelableInterval(async (stop) => {
-                logger('waitForFileWithContent', filePath);
-                if (isBusy) {
-                    return;
-                }
-                isBusy = true;
-                try {
-                    // Try to read the file to check if it has content
-                    const file = await this.readFile(filePath);
-                    if (file.size > 0) {
-                        stop();
-                        resolve(true);
-                        return;
-                    }
-                    // File exists but is 0 bytes, continue waiting
-                }
-                catch (error) {
-                    // If error is about file being 0 bytes, not readable, or I/O error, continue waiting
-                    const errorMessage = error?.message || String(error);
-                    if (errorMessage.includes('0 bytes') ||
-                        errorMessage.includes('ENOENT') ||
-                        errorMessage.includes('EIO') ||
-                        errorMessage.includes('Input/output error') ||
-                        isTransientOpfsReadError(error)) ;
-                    else {
-                        // Other errors should be thrown
-                        stop();
-                        reject(error);
-                        return;
-                    }
-                }
-                if (Date.now() - startTime >= timeout) {
-                    stop();
-                    reject(new Error(`Timeout exceeded while waiting for file ${filePath} to have content`));
-                    return;
-                }
-                isBusy = false;
-            }, interval);
-            cancelableInterval.start();
-        });
-    }
-    static async saveFile(filePath, content) {
-        const zenfs = await this.getFs();
-        // Convert content to a format that zenfs.writeFile accepts
-        let writeContent;
-        if (typeof content === 'string') {
-            writeContent = content;
-        }
-        else if (content instanceof Blob) {
-            const arrayBuffer = await content.arrayBuffer();
-            writeContent = new Uint8Array(arrayBuffer);
-        }
-        else if (content instanceof ArrayBuffer) {
-            writeContent = new Uint8Array(content);
-        }
-        else {
-            throw new Error('Unsupported content type');
-        }
-        await zenfs.writeFile(filePath, writeContent);
-        await this.waitForFileWithContent(filePath, 100, 5000);
-        // try {
-        //   // Get a handle to the OPFS root directory
-        //   const root = await navigator.storage.getDirectory();
-        //   // Split the file path into directory and file name
-        //   const pathParts = filePath.split('/');
-        //   const fileName = pathParts.pop();
-        //   if (!fileName) throw new Error('Invalid file path');
-        //   // Traverse directories and create them if they don't exist
-        //   let currentDir = root;
-        //   for (const part of pathParts) {
-        //     if (part !== '') {
-        //       currentDir = await currentDir.getDirectoryHandle(part, { create: true });
-        //     }
-        //   }
-        //   // Get the file handle and create the file if it doesn't exist
-        //   const fileHandle = await currentDir.getFileHandle(fileName, { create: true });
-        //   // Create a writable stream and write the content
-        //   const writable = await fileHandle.createWritable();
-        //   if (typeof content === 'string' || content instanceof Uint8Array) {
-        //       await writable.write(content);
-        //   } else if (content instanceof Blob) {
-        //       await writable.write(content);
-        //   } else if (content instanceof ArrayBuffer) {
-        //       await writable.write(new Blob([content]));
-        //   } else {
-        //       throw new Error('Unsupported content type');
-        //   }
-        //   await writable.close();
-        //   logger(`File written successfully: ${filePath}`);
-        // } catch (error) {
-        //     console.error(`Error writing to OPFS: ${error.message}`);
-        // }
-    }
-    static saveFileSync(filePath, content) {
-        // Note: This is a synchronous wrapper, but zenfs operations may still be async under the hood
-        // For true sync operations in browser, we'd need to use OPFS sync access handles
-        // For now, we'll use zenfs.writeFileSync which should be available
-        const zenfs = this.getFsSync();
-        // Convert content to a format that zenfs.writeFileSync accepts
-        let writeContent;
-        if (typeof content === 'string') {
-            writeContent = content;
-        }
-        else if (content instanceof Blob) {
-            // Blob cannot be converted synchronously - throw error
-            throw new Error('Blob content not supported in saveFileSync. Use saveFile() instead or convert to ArrayBuffer first.');
-        }
-        else if (content instanceof ArrayBuffer) {
-            writeContent = new Uint8Array(content);
-        }
-        else {
-            throw new Error('Unsupported content type');
-        }
-        zenfs.writeFileSync(filePath, writeContent);
-    }
-    static async readFile(filePath) {
-        const zenfs = await this.getFs();
-        const maxAttempts = 3;
-        const baseDelayMs = 50;
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            try {
-                const data = await zenfs.promises.readFile(filePath);
-                return new File([new Uint8Array(data)], filePath);
-            }
-            catch (error) {
-                if (!isTransientOpfsReadError(error) || attempt === maxAttempts - 1) {
-                    throw error;
-                }
-                await sleep(baseDelayMs * (attempt + 1));
-            }
-        }
-        throw new Error('readFile: exhausted retries');
-        // try {
-        //   // Get a handle to the OPFS root directory
-        //   const root = await navigator.storage.getDirectory();
-        //    // Split the file path into directory and file name
-        //    const pathParts = filePath.split('/');
-        //    const fileName = pathParts.pop();
-        //    if (!fileName) throw new Error('Invalid file path');
-        //    // Traverse directories to reach the target file
-        //    let currentDir = root;
-        //    for (const part of pathParts) {
-        //      if (part !== '') {
-        //        currentDir = await currentDir.getDirectoryHandle(part, { create: false });
-        //      }
-        //    }
-        //    // Get the file handle
-        //    const fileHandle = await currentDir.getFileHandle(fileName, { create: false });
-        //    // Get the file and read it as an ArrayBuffer
-        //    return await fileHandle.getFile();
-        // } catch (error) {
-        //   console.error(`Error reading from OPFS: ${error.message}`);
-        //   throw error;
-        // }
-    }
-    static readFileSync(filePath) {
-        // Note: This is a synchronous wrapper, but zenfs operations may still be async under the hood
-        // For true sync operations in browser, we'd need to use OPFS sync access handles
-        // For now, we'll use zenfs.readFileSync which should be available
-        const zenfs = this.getFsSync();
-        const file = zenfs.readFileSync(filePath);
-        return new File([new Uint8Array(file)], filePath);
-    }
-    static async readFileAsBuffer(filePath) {
-        try {
-            // Get the file and read it as an ArrayBuffer
-            const file = await this.readFile(filePath);
-            const arrayBuffer = await file.arrayBuffer();
-            // Convert ArrayBuffer to Blob
-            return new Blob([arrayBuffer]);
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            console.error(`Error reading from OPFS: ${errorMessage}`);
-            throw error;
-        }
-    }
-    static async readFileAsString(filePath) {
-        const blob = await this.readFileAsBuffer(filePath);
-        return blob.text();
-    }
-    static getParentDirPath(filePath) {
-        return pathCompat.dirname(filePath);
-    }
-    static getFilenameFromPath(filePath) {
-        return pathCompat.basename(filePath);
-    }
-    static getPathModule() {
-        return pathCompat;
-    }
-}
-FileManager.zenfsCache = null;
-class CancelableInterval {
-    constructor(task, interval) {
-        this.task = task;
-        this.interval = interval;
-        this.intervalId = null;
-        this.currentTaskAbortController = null;
-    }
-    start() {
-        this.intervalId = window.setInterval(async () => {
-            if (this.currentTaskAbortController) {
-                // Cancel the previous running task
-                this.currentTaskAbortController.abort();
-            }
-            // Create a new abort controller for the current task
-            this.currentTaskAbortController = new AbortController();
-            const signal = this.currentTaskAbortController.signal;
-            try {
-                await this.taskWithCancellation(signal);
-            }
-            catch (error) {
-                if (error instanceof DOMException && error.name === 'AbortError') {
-                    logger('Previous task was canceled.');
-                }
-                else {
-                    console.error('Task error:', error);
-                }
-                this.stop();
-            }
-        }, this.interval);
-    }
-    async taskWithCancellation(signal) {
-        await this.task(() => this.stop());
-        if (signal.aborted) {
-            throw new DOMException('Task was aborted', 'AbortError');
-        }
-    }
-    stop() {
-        if (this.intervalId !== null) {
-            clearInterval(this.intervalId);
-            this.intervalId = null;
-        }
-        if (this.currentTaskAbortController) {
-            this.currentTaskAbortController.abort();
-        }
-    }
-}
-
-export { FileManager };
-//# sourceMappingURL=FileManager-5GkHtxF7.js.map