@pistonite/pure 0.27.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pistonite/pure",
-  "version": "0.27.0",
+  "version": "0.28.0",
   "type": "module",
   "description": "Pure TypeScript libraries for my projects",
   "homepage": "https://github.com/Pistonite/pure",
@@ -28,7 +28,7 @@
   },
   "devDependencies": {
     "vitest": "^3.2.4",
-    "mono-dev": "0.2.3"
+    "mono-dev": "0.2.7"
   },
   "dependencies": {
     "denque": "^2.1.0"

package/src/fs/FsFile.ts

@@ -33,7 +33,7 @@ export interface FsFile {
      * Set the content in memory. Does not save to disk.
      * Does nothing if file is closed
      */
-    setBytes(content: Uint8Array): void;
+    setBytes(content: Uint8Array<ArrayBuffer>): void;
 
     /**
      * Load the file's content if it's not newer than fs

package/src/fs/FsFileImpl.ts

@@ -24,7 +24,7 @@ class FsFileImpl implements FsFile {
     /** If the file is text */
     private isText: boolean;
     /** Bytes of the file */
-    private buffer: Uint8Array | undefined;
+    private buffer: Uint8Array<ArrayBuffer> | undefined;
     /** If the content in the buffer is different from the content on FS */
     private isBufferDirty: boolean;
     /** The content string of the file */
@@ -97,9 +97,7 @@ class FsFileImpl implements FsFile {
             }
         }
         if (this.buffer === undefined) {
-            const err = fsFail(
-                "Read was successful, but content was undefined",
-            );
+            const err = fsFail("Read was successful, but content was undefined");
             return { err };
         }
         return { val: this.buffer };
@@ -117,7 +115,7 @@ class FsFileImpl implements FsFile {
         this.lastModified = new Date().getTime();
     }
 
-    public setBytes(content: Uint8Array): void {
+    public setBytes(content: Uint8Array<ArrayBuffer>): void {
         if (this.closed) {
             return;
         }
@@ -155,9 +153,7 @@ class FsFileImpl implements FsFile {
         }
         this.lastModified = file.lastModified;
         // load the buffer
-        const buffer = await tryAsync(
-            async () => new Uint8Array(await file.arrayBuffer()),
-        );
+        const buffer = await tryAsync(async () => new Uint8Array(await file.arrayBuffer()));
         if ("err" in buffer) {
             const err = fsFail(errstr(buffer.err));
             return { err };
@@ -202,9 +198,7 @@ class FsFileImpl implements FsFile {
 
     private decodeBuffer() {
         try {
-            this.content = new TextDecoder("utf-8", { fatal: true }).decode(
-                this.buffer,
-            );
+            this.content = new TextDecoder("utf-8", { fatal: true }).decode(this.buffer);
             this.isText = true;
         } catch {
             this.content = undefined;

package/src/fs/FsFileStandaloneImplHandleAPI.ts

@@ -104,14 +104,11 @@ export class FsFileStandaloneImplHandleAPI implements FsFileStandalone {
             return { err: fsFail(errstr(e)) };
         }
     }
-    public async write(content: Uint8Array | string): Promise<FsVoid> {
+    public async write(content: Uint8Array<ArrayBuffer> | string): Promise<FsVoid> {
         const writable = await this.isWritable();
         if (!writable) {
             return {
-                err: fsErr(
-                    FsErr.NotSupported,
-                    "Permission was not granted or API not supported",
-                ),
+                err: fsErr(FsErr.NotSupported, "Permission was not granted or API not supported"),
             };
         }
         try {
@@ -131,10 +128,7 @@ export class FsFileStandaloneImplHandleAPI implements FsFileStandalone {
                 }
                 if (e.name === "NoMidificationAllowedError") {
                     return {
-                        err: fsErr(
-                            FsErr.PermissionDenied,
-                            "Failed to acquire write lock",
-                        ),
+                        err: fsErr(FsErr.PermissionDenied, "Failed to acquire write lock"),
                     };
                 }
                 if (e.name === "AbortError") {

package/src/fs/FsFileSystemInternal.ts

@@ -21,7 +21,7 @@ export interface FsFileSystemInternal {
      * Returns NotSupported if the browser does not support this
      * Returns PermissionDenied if the operation is supported, but permission is not given
      */
-    write: (path: string, content: Uint8Array) => Promise<FsVoid>;
+    write: (path: string, content: Uint8Array<ArrayBuffer>) => Promise<FsVoid>;
 
     /**
      * Forget about a file

package/src/fs/FsImplEntryAPI.ts

@@ -1,20 +1,14 @@
 import { type Ok, tryAsync, errstr } from "../result/index.ts";
 
 import { FsErr, type FsResult, type FsVoid, fsErr, fsFail } from "./FsError.ts";
-import type {
-    FsFileSystem,
-    FsFileSystemUninit,
-    FsCapabilities,
-} from "./FsFileSystem.ts";
+import type { FsFileSystem, FsFileSystemUninit, FsCapabilities } from "./FsFileSystem.ts";
 import type { FsFile } from "./FsFile.ts";
 import { fsIsRoot, fsNormalize } from "./FsPath.ts";
 import { FsFileMgr } from "./FsFileMgr.ts";
 import type { FsFileSystemInternal } from "./FsFileSystemInternal.ts";
 
 /** FsFileSystem implementation that uses FileEntry API */
-export class FsImplEntryAPI
-    implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal
-{
+export class FsImplEntryAPI implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal {
     public root: string;
     public capabilities: FsCapabilities;
 
@@ -53,12 +47,7 @@ export class FsImplEntryAPI
                 }),
         );
         if ("err" in entries) {
-            const err = fsFail(
-                "Failed to list directory `" +
-                    path +
-                    "`: " +
-                    errstr(entries.err),
-            );
+            const err = fsFail("Failed to list directory `" + path + "`: " + errstr(entries.err));
             return { err };
         }
 
@@ -91,9 +80,7 @@ export class FsImplEntryAPI
                 }),
         );
         if ("err" in file) {
-            const err = fsFail(
-                "Failed to read file `" + path + "`: " + errstr(file.err),
-            );
+            const err = fsFail("Failed to read file `" + path + "`: " + errstr(file.err));
             return { err };
         }
 
@@ -101,10 +88,7 @@ export class FsImplEntryAPI
     }
 
     public write(): Promise<FsVoid> {
-        const err = fsErr(
-            FsErr.NotSupported,
-            "Write not supported in FileEntry API",
-        );
+        const err = fsErr(FsErr.NotSupported, "Write not supported in FileEntry API");
         return Promise.resolve({ err });
     }
 
@@ -119,9 +103,7 @@ export class FsImplEntryAPI
     }
 
     /** Resolve a directory entry. Path must be normalized */
-    private async resolveDir(
-        path: string,
-    ): Promise<FsResult<FileSystemDirectoryEntry>> {
+    private async resolveDir(path: string): Promise<FsResult<FileSystemDirectoryEntry>> {
         if (fsIsRoot(path)) {
             return { val: this.rootEntry };
         }
@@ -132,33 +114,20 @@ export class FsImplEntryAPI
                 }),
         );
         if ("err" in entry) {
-            const err = fsFail(
-                "Failed to resolve directory `" +
-                    path +
-                    "`: " +
-                    errstr(entry.err),
-            );
+            const err = fsFail("Failed to resolve directory `" + path + "`: " + errstr(entry.err));
             return { err };
         }
         if (!entry.val.isDirectory) {
-            const err = fsErr(
-                FsErr.IsFile,
-                "Path `" + path + "` is not a directory",
-            );
+            const err = fsErr(FsErr.IsFile, "Path `" + path + "` is not a directory");
             return { err };
         }
         return entry as Ok<FileSystemDirectoryEntry>;
     }
 
     /** Resolve a file entry. Path must be normalized */
-    private async resolveFile(
-        path: string,
-    ): Promise<FsResult<FileSystemFileEntry>> {
+    private async resolveFile(path: string): Promise<FsResult<FileSystemFileEntry>> {
         if (fsIsRoot(path)) {
-            const err = fsErr(
-                FsErr.IsDirectory,
-                "Path `" + path + "` is not a file",
-            );
+            const err = fsErr(FsErr.IsDirectory, "Path `" + path + "` is not a file");
             return { err };
         }
         const entry = await tryAsync(
@@ -168,16 +137,11 @@ export class FsImplEntryAPI
                 }),
         );
         if ("err" in entry) {
-            const err = fsFail(
-                "Failed to resolve file `" + path + "`: " + errstr(entry.err),
-            );
+            const err = fsFail("Failed to resolve file `" + path + "`: " + errstr(entry.err));
             return { err };
         }
         if (!entry.val.isFile) {
-            const err = fsErr(
-                FsErr.IsDirectory,
-                "Path `" + path + "` is not a file",
-            );
+            const err = fsErr(FsErr.IsDirectory, "Path `" + path + "` is not a file");
             return { err };
         }
         return entry as Ok<FileSystemFileEntry>;

package/src/fs/FsImplFileAPI.ts

@@ -1,11 +1,7 @@
 import { ilog } from "../log/internal.ts";
 
 import type { FsFile } from "./FsFile.ts";
-import type {
-    FsFileSystem,
-    FsFileSystemUninit,
-    FsCapabilities,
-} from "./FsFileSystem.ts";
+import type { FsFileSystem, FsFileSystemUninit, FsCapabilities } from "./FsFileSystem.ts";
 import { FsErr, type FsResult, type FsVoid, fsErr } from "./FsError.ts";
 import { fsIsRoot, fsNormalize } from "./FsPath.ts";
 import { FsFileMgr } from "./FsFileMgr.ts";
@@ -17,9 +13,7 @@ import type { FsFileSystemInternal } from "./FsFileSystemInternal.ts";
  * It's used for Firefox when the File Entries API is not available
  * i.e. opened from <input type="file">
  */
-export class FsImplFileAPI
-    implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal
-{
+export class FsImplFileAPI implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal {
     public root: string;
     public capabilities: FsCapabilities;
 
@@ -106,10 +100,7 @@ export class FsImplFileAPI
     }
 
     public write(): Promise<FsVoid> {
-        const err = fsErr(
-            FsErr.NotSupported,
-            "Write not supported in File API",
-        );
+        const err = fsErr(FsErr.NotSupported, "Write not supported in File API");
         return Promise.resolve({ err });
     }
 

package/src/fs/FsImplHandleAPI.ts

@@ -5,20 +5,10 @@
 
 import { tryAsync, errstr } from "../result/index.ts";
 
-import type {
-    FsFileSystem,
-    FsFileSystemUninit,
-    FsCapabilities,
-} from "./FsFileSystem.ts";
+import type { FsFileSystem, FsFileSystemUninit, FsCapabilities } from "./FsFileSystem.ts";
 import { FsErr, type FsResult, type FsVoid, fsErr, fsFail } from "./FsError.ts";
 import type { FsFile } from "./FsFile.ts";
-import {
-    fsComponents,
-    fsGetBase,
-    fsGetName,
-    fsIsRoot,
-    fsNormalize,
-} from "./FsPath.ts";
+import { fsComponents, fsGetBase, fsGetName, fsIsRoot, fsNormalize } from "./FsPath.ts";
 import { FsFileMgr } from "./FsFileMgr.ts";
 import type { FsFileSystemInternal } from "./FsFileSystemInternal.ts";
 
@@ -28,9 +18,7 @@ type PermissionStatus = "granted" | "denied" | "prompt";
  * FsFileSystem implementation that uses FileSystem Access API
  * This is only supported in Chrome/Edge
  */
-export class FsImplHandleAPI
-    implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal
-{
+export class FsImplHandleAPI implements FsFileSystemUninit, FsFileSystem, FsFileSystemInternal {
     public root: string;
     public capabilities: FsCapabilities;
     /** If app requested write access */
@@ -40,11 +28,7 @@ export class FsImplHandleAPI
 
     private mgr: FsFileMgr;
 
-    constructor(
-        rootPath: string,
-        rootHandle: FileSystemDirectoryHandle,
-        write: boolean,
-    ) {
+    constructor(rootPath: string, rootHandle: FileSystemDirectoryHandle, write: boolean) {
         this.root = rootPath;
         this.rootHandle = rootHandle;
         this.writeMode = write;
@@ -92,10 +76,7 @@ export class FsImplHandleAPI
         });
         if ("err" in entries) {
             const err = fsFail(
-                "Error reading entries from directory `" +
-                    path +
-                    "`: " +
-                    errstr(entries.err),
+                "Error reading entries from directory `" + path + "`: " + errstr(entries.err),
             );
             return { err };
         }
@@ -116,20 +97,15 @@ export class FsImplHandleAPI
 
         const file = await tryAsync(() => handle.val.getFile());
         if ("err" in file) {
-            const err = fsFail(
-                "Failed to read file `" + path + "`: " + errstr(file.err),
-            );
+            const err = fsFail("Failed to read file `" + path + "`: " + errstr(file.err));
             return { err };
         }
         return file;
     }
 
-    public async write(path: string, content: Uint8Array): Promise<FsVoid> {
+    public async write(path: string, content: Uint8Array<ArrayBuffer>): Promise<FsVoid> {
         if (!this.writeMode) {
-            const err = fsErr(
-                FsErr.PermissionDenied,
-                "Write mode not requested",
-            );
+            const err = fsErr(FsErr.PermissionDenied, "Write mode not requested");
             return { err };
         }
         const normalized = fsNormalize(path);
@@ -150,9 +126,7 @@ export class FsImplHandleAPI
             return {};
         });
         if ("err" in result) {
-            const err = fsFail(
-                "Failed to write file `" + path + "`: " + errstr(result.err),
-            );
+            const err = fsFail("Failed to write file `" + path + "`: " + errstr(result.err));
             return { err };
         }
         return {};
@@ -173,9 +147,7 @@ export class FsImplHandleAPI
      * Resolve the FileSystemDirectoryHandle for a directory.
      * The path must be normalized
      */
-    private async resolveDir(
-        path: string,
-    ): Promise<FsResult<FileSystemDirectoryHandle>> {
+    private async resolveDir(path: string): Promise<FsResult<FileSystemDirectoryHandle>> {
         if (fsIsRoot(path)) {
             return { val: this.rootHandle };
         }
@@ -187,10 +159,7 @@ export class FsImplHandleAPI
             if ("err" in next) {
                 const dir = parts.join("/");
                 const err = fsFail(
-                    "Failed to resolve directory `" +
-                        dir +
-                        "`: " +
-                        errstr(next.err),
+                    "Failed to resolve directory `" + dir + "`: " + errstr(next.err),
                 );
                 return { err };
             }
@@ -204,9 +173,7 @@ export class FsImplHandleAPI
      * Resolve the FileSystemFileHandle for a file.
      * The path must be normalized
      */
-    private async resolveFile(
-        path: string,
-    ): Promise<FsResult<FileSystemFileHandle>> {
+    private async resolveFile(path: string): Promise<FsResult<FileSystemFileHandle>> {
         const parent = fsGetBase(path);
         if (parent.err) {
             return parent;
@@ -224,9 +191,7 @@ export class FsImplHandleAPI
 
         const file = await tryAsync(() => handle.val.getFileHandle(name.val));
         if ("err" in file) {
-            const err = fsFail(
-                "Failed to resolve file `" + path + "`: " + errstr(file.err),
-            );
+            const err = fsFail("Failed to resolve file `" + path + "`: " + errstr(file.err));
             return { err };
         }
         return file;

package/src/fs/FsOpen.ts

@@ -1,23 +1,14 @@
 import { tryCatch, tryAsync, errstr } from "../result/index.ts";
 
 import type { FsFileSystem, FsFileSystemUninit } from "./FsFileSystem.ts";
-import {
-    FsErr,
-    type FsError,
-    type FsResult,
-    fsErr,
-    fsFail,
-} from "./FsError.ts";
+import { FsErr, type FsError, type FsResult, fsErr, fsFail } from "./FsError.ts";
 import { fsGetSupportStatus } from "./FsSupportStatus.ts";
 import { FsImplFileAPI } from "./FsImplFileAPI.ts";
 import { FsImplEntryAPI } from "./FsImplEntryAPI.ts";
 import { FsImplHandleAPI } from "./FsImplHandleAPI.ts";
 
 /** Handle for handling top level open errors, and decide if the operation should be retried */
-export type FsOpenRetryHandler = (
-    error: FsError,
-    attempt: number,
-) => Promise<FsResult<boolean>>;
+export type FsOpenRetryHandler = (error: FsError, attempt: number) => Promise<FsResult<boolean>>;
 
 const MAX_RETRY = 10;
 
@@ -105,29 +96,22 @@ async function createWithPicker(
         inputElement.type = "file";
         inputElement.webkitdirectory = true;
 
-        const fsUninit = await new Promise<FsResult<FsFileSystemUninit>>(
-            (resolve) => {
-                inputElement.addEventListener("change", (event) => {
-                    const files = (event.target as HTMLInputElement).files;
-                    if (!files) {
-                        const err = fsFail(
-                            "Failed to get files from input element",
-                        );
-                        return resolve({ err });
-                    }
-                    resolve(createFromFileList(files));
-                });
-                inputElement.addEventListener("cancel", () => {
-                    resolve({
-                        err: fsErr(
-                            FsErr.UserAbort,
-                            "User cancelled the operation",
-                        ),
-                    });
+        const fsUninit = await new Promise<FsResult<FsFileSystemUninit>>((resolve) => {
+            inputElement.addEventListener("change", (event) => {
+                const files = (event.target as HTMLInputElement).files;
+                if (!files) {
+                    const err = fsFail("Failed to get files from input element");
+                    return resolve({ err });
+                }
+                resolve(createFromFileList(files));
+            });
+            inputElement.addEventListener("cancel", () => {
+                resolve({
+                    err: fsErr(FsErr.UserAbort, "User cancelled the operation"),
                 });
-                inputElement.click();
-            },
-        );
+            });
+            inputElement.click();
+        });
         inputElement.remove();
 
         if (fsUninit.val) {
@@ -159,36 +143,21 @@ async function createFromDataTransferItem(
         let error: FsError | undefined = undefined;
         const { implementation } = fsGetSupportStatus();
         // Prefer File System Access API since it supports writing
-        if (
-            "getAsFileSystemHandle" in item &&
-            implementation === "FileSystemAccess"
-        ) {
+        if ("getAsFileSystemHandle" in item && implementation === "FileSystemAccess") {
             const handle = await tryAsync(() => getAsFileSystemHandle(item));
             if (handle.val) {
                 return createFromFileSystemHandle(handle.val, write);
             }
-            error = fsFail(
-                "Failed to get handle from DataTransferItem: " +
-                    errstr(handle.err),
-            );
-        } else if (
-            "webkitGetAsEntry" in item &&
-            implementation === "FileEntry"
-        ) {
+            error = fsFail("Failed to get handle from DataTransferItem: " + errstr(handle.err));
+        } else if ("webkitGetAsEntry" in item && implementation === "FileEntry") {
             const entry = tryCatch(() => webkitGetAsEntry(item));
             if (entry.val) {
                 return createFromFileSystemEntry(entry.val);
             }
-            error = fsFail(
-                "Failed to get entry from DataTransferItem: " +
-                    errstr(entry.err),
-            );
+            error = fsFail("Failed to get entry from DataTransferItem: " + errstr(entry.err));
         }
         if (!error) {
-            const err = fsErr(
-                FsErr.NotSupported,
-                "No supported API found on the DataTransferItem",
-            );
+            const err = fsErr(FsErr.NotSupported, "No supported API found on the DataTransferItem");
             return { err };
         }
         // handle error
@@ -248,15 +217,11 @@ function showDirectoryPicker(write: boolean): Promise<FileSystemHandle> {
  * @param e The error to check
  */
 function isAbortError(e: unknown): boolean {
-    return (
-        !!e && typeof e === "object" && "name" in e && e.name === "AbortError"
-    );
+    return !!e && typeof e === "object" && "name" in e && e.name === "AbortError";
 }
 
 /** Wrapper for DataTransferItem.getAsFileSystemHandle */
-async function getAsFileSystemHandle(
-    item: DataTransferItem,
-): Promise<FileSystemHandle> {
+async function getAsFileSystemHandle(item: DataTransferItem): Promise<FileSystemHandle> {
     // @ts-expect-error getAsFileSystemHandle is not in the TS lib
     const handle = await item.getAsFileSystemHandle();
     if (!handle) {
@@ -283,26 +248,17 @@ function createFromFileSystemHandle(
         return { err };
     }
 
-    const fs = new FsImplHandleAPI(
-        handle.name,
-        handle as FileSystemDirectoryHandle,
-        write,
-    );
+    const fs = new FsImplHandleAPI(handle.name, handle as FileSystemDirectoryHandle, write);
 
     return { val: fs };
 }
 
-function createFromFileSystemEntry(
-    entry: FileSystemEntry,
-): FsResult<FsFileSystemUninit> {
+function createFromFileSystemEntry(entry: FileSystemEntry): FsResult<FsFileSystemUninit> {
     if (entry.isFile || !entry.isDirectory) {
         const err = fsErr(FsErr.IsFile, "Expected directory");
         return { err };
     }
-    const fs = new FsImplEntryAPI(
-        entry.name,
-        entry as FileSystemDirectoryEntry,
-    );
+    const fs = new FsImplEntryAPI(entry.name, entry as FileSystemDirectoryEntry);
     return { val: fs };
 }
 

package/src/fs/FsOpenFile.ts

@@ -52,10 +52,7 @@ const fsOpenFileInternal = async (
     options: FsFileOpenOptions,
 ): Promise<FsResult<FsFileStandalone[]>> => {
     if (isFileSystemAccessAPISupportedForStandaloneFileOpen()) {
-        const result = await fsOpenFileWithFileSystemAccessAPI(
-            multiple,
-            options,
-        );
+        const result = await fsOpenFileWithFileSystemAccessAPI(multiple, options);
         if (result.val || result.err.code === FsErr.UserAbort) {
             return result;
         }
@@ -116,9 +113,7 @@ const fsOpenFileWithFileAPI = async (
                 }
                 const array = [];
                 for (let i = 0; i < element.files.length; i++) {
-                    array.push(
-                        new FsFileStandaloneImplFileAPI(element.files[i]),
-                    );
+                    array.push(new FsFileStandaloneImplFileAPI(element.files[i]));
                 }
                 resolve({ val: array });
             });

package/src/fs/FsSave.ts

@@ -3,7 +3,7 @@ import { ilog } from "../log/internal.ts";
 import { fsFail, type FsVoid } from "./FsError.ts";
 
 /** Save (download) a file using Blob */
-export function fsSave(content: string | Uint8Array, filename: string): FsVoid {
+export function fsSave(content: string | Uint8Array<ArrayBuffer>, filename: string): FsVoid {
     const blob = new Blob([content], {
         // maybe lying, but should be fine
         type: "text/plain;charset=utf-8",
@@ -32,11 +32,7 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-type SaveAsFn = (
-    data: Blob | string,
-    filename?: string,
-    options?: SaveAsFnOptions,
-) => void;
+type SaveAsFn = (data: Blob | string, filename?: string, options?: SaveAsFnOptions) => void;
 type SaveAsFnOptions = { autoBom: boolean };
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -184,8 +180,7 @@ const saveAs: SaveAsFn = (blob, name?, opts?) => {
     const force = blob.type === "application/octet-stream";
     // adoption note: add any
     const isSafari =
-        /constructor/i.test((globalThis as any).HTMLElement) ||
-        (globalThis as any).safari;
+        /constructor/i.test((globalThis as any).HTMLElement) || (globalThis as any).safari;
     const isChromeIOS = /CriOS\/[\d]+/.test(navigator.userAgent);
 
     if (
@@ -196,9 +191,7 @@ const saveAs: SaveAsFn = (blob, name?, opts?) => {
         const reader = new FileReader();
         reader.onloadend = function () {
             let url = reader.result as string;
-            url = isChromeIOS
-                ? url
-                : url.replace(/^data:[^;]*;/, "data:attachment/file;");
+            url = isChromeIOS ? url : url.replace(/^data:[^;]*;/, "data:attachment/file;");
             if (popup) {
                 popup.location.href = url;
             } else {

package/src/fs/FsSupportStatus.ts

@@ -71,11 +71,7 @@ function isFileEntrySupported(): boolean {
     // Chrome/Edge has this but it's named DirectoryEntry
     // AND, they don't work (I forgot how exactly they don't work)
 
-    if (
-        navigator &&
-        navigator.userAgent &&
-        navigator.userAgent.includes("Chrome")
-    ) {
+    if (navigator && navigator.userAgent && navigator.userAgent.includes("Chrome")) {
         return false;
     }