cspell-io 8.1.2 → 8.2.0

package/dist/esm/VirtualFS.js

@@ -0,0 +1,326 @@
+import { urlOrReferenceToUrl } from './common/index.js';
+import { getDefaultCSpellIO } from './CSpellIONode.js';
+import { FileType, } from './models/index.js';
+export var FSCapabilityFlags;
+(function (FSCapabilityFlags) {
+    FSCapabilityFlags[FSCapabilityFlags["None"] = 0] = "None";
+    FSCapabilityFlags[FSCapabilityFlags["Stat"] = 1] = "Stat";
+    FSCapabilityFlags[FSCapabilityFlags["Read"] = 2] = "Read";
+    FSCapabilityFlags[FSCapabilityFlags["Write"] = 4] = "Write";
+    FSCapabilityFlags[FSCapabilityFlags["ReadWrite"] = 6] = "ReadWrite";
+    FSCapabilityFlags[FSCapabilityFlags["ReadDir"] = 8] = "ReadDir";
+    FSCapabilityFlags[FSCapabilityFlags["WriteDir"] = 16] = "WriteDir";
+    FSCapabilityFlags[FSCapabilityFlags["ReadWriteDir"] = 24] = "ReadWriteDir";
+})(FSCapabilityFlags || (FSCapabilityFlags = {}));
+class CVirtualFS {
+    providers = new Set();
+    cachedFs = new Map();
+    revCacheFs = new Map();
+    fs;
+    constructor() {
+        this.fs = fsPassThrough((url) => this._getFS(url));
+    }
+    registerFileSystemProvider(...providers) {
+        providers.forEach((provider) => this.providers.add(provider));
+        this.reset();
+        return {
+            dispose: () => {
+                for (const provider of providers) {
+                    for (const key of this.revCacheFs.get(provider) || []) {
+                        this.cachedFs.delete(key);
+                    }
+                    this.providers.delete(provider) && undefined;
+                }
+                this.reset();
+            },
+        };
+    }
+    getFS(url) {
+        return this._getFS(url);
+    }
+    _getFS(url) {
+        const key = `${url.protocol}${url.hostname}`;
+        const cached = this.cachedFs.get(key);
+        if (cached) {
+            return cached;
+        }
+        const fnNext = (provider, next) => {
+            return (url) => {
+                let calledNext = false;
+                const fs = provider.getFileSystem(url, (_url) => {
+                    calledNext = calledNext || url === _url;
+                    return next(_url);
+                });
+                if (fs) {
+                    const s = this.revCacheFs.get(provider) || new Set();
+                    s.add(key);
+                    this.revCacheFs.set(provider, s);
+                    return fs;
+                }
+                if (!calledNext) {
+                    return next(url);
+                }
+                return undefined;
+            };
+        };
+        let next = (_url) => undefined;
+        for (const provider of this.providers) {
+            next = fnNext(provider, next);
+        }
+        const fs = new WrappedProviderFs(next(url));
+        this.cachedFs.set(key, fs);
+        return fs;
+    }
+    reset() {
+        this.cachedFs.clear();
+        this.revCacheFs.clear();
+        this.disposeOfCachedFs();
+    }
+    disposeOfCachedFs() {
+        for (const [key, fs] of [...this.cachedFs].reverse()) {
+            try {
+                WrappedProviderFs.disposeOf(fs);
+            }
+            catch (e) {
+                // continue - we are cleaning up.
+            }
+            this.cachedFs.delete(key);
+        }
+        this.cachedFs.clear();
+    }
+    dispose() {
+        this.disposeOfCachedFs();
+        const providers = [...this.providers].reverse();
+        for (const provider of providers) {
+            try {
+                provider.dispose?.();
+            }
+            catch (e) {
+                // continue - we are cleaning up.
+            }
+        }
+    }
+}
+function fsPassThrough(fs) {
+    function gfs(ur, name) {
+        const url = urlOrReferenceToUrl(ur);
+        const f = fs(url);
+        if (!f.hasProvider)
+            throw new VFSErrorUnsupportedRequest(name, url, ur instanceof URL ? undefined : { url: ur.url.toString(), encoding: ur.encoding });
+        return f;
+    }
+    return {
+        providerInfo: { name: 'default' },
+        hasProvider: true,
+        stat: async (url) => gfs(url, 'stat').stat(url),
+        readFile: async (url) => gfs(url, 'readFile').readFile(url),
+        writeFile: async (file) => gfs(file, 'writeFile').writeFile(file),
+        readDirectory: async (url) => gfs(url, 'readDirectory')
+            .readDirectory(url)
+            .then((entries) => entries.map((e) => new CVfsDirEntry(e))),
+        getCapabilities: (url) => gfs(url, 'getCapabilities').getCapabilities(url),
+    };
+}
+export function createVirtualFS(cspellIO) {
+    const cspell = cspellIO || getDefaultCSpellIO();
+    const vfs = new CVirtualFS();
+    vfs.registerFileSystemProvider(cspellIOToFsProvider(cspell));
+    return vfs;
+}
+function cspellIOToFsProvider(cspellIO) {
+    const capabilities = FSCapabilityFlags.Stat | FSCapabilityFlags.ReadWrite | FSCapabilityFlags.ReadDir;
+    const capabilitiesHttp = capabilities & ~FSCapabilityFlags.Write & ~FSCapabilityFlags.ReadDir;
+    const capMap = {
+        'file:': capabilities,
+        'http:': capabilitiesHttp,
+        'https:': capabilitiesHttp,
+    };
+    const name = 'CSpellIO';
+    const supportedProtocols = new Set(['file:', 'http:', 'https:']);
+    const fs = {
+        providerInfo: { name },
+        stat: (url) => cspellIO.getStat(url),
+        readFile: (url) => cspellIO.readFile(url),
+        readDirectory: (url) => cspellIO.readDirectory(url),
+        writeFile: (file) => cspellIO.writeFile(file.url, file.content),
+        dispose: () => undefined,
+        capabilities,
+        getCapabilities(url) {
+            return fsCapabilities(capMap[url.protocol] || FSCapabilityFlags.None);
+        },
+    };
+    return {
+        name,
+        getFileSystem: (url, _next) => {
+            return supportedProtocols.has(url.protocol) ? fs : undefined;
+        },
+    };
+}
+let defaultVirtualFs = undefined;
+export function getDefaultVirtualFs() {
+    if (!defaultVirtualFs) {
+        defaultVirtualFs = createVirtualFS();
+    }
+    return defaultVirtualFs;
+}
+function wrapError(e) {
+    if (e instanceof VFSError)
+        return e;
+    // return new VFSError(e instanceof Error ? e.message : String(e), { cause: e });
+    return e;
+}
+export class VFSError extends Error {
+    constructor(message, options) {
+        super(message, options);
+    }
+}
+export class VFSErrorUnsupportedRequest extends VFSError {
+    request;
+    parameters;
+    url;
+    constructor(request, url, parameters) {
+        super(`Unsupported request: ${request}`);
+        this.request = request;
+        this.parameters = parameters;
+        this.url = url?.toString();
+    }
+}
+class CFsCapabilities {
+    flags;
+    constructor(flags) {
+        this.flags = flags;
+    }
+    get readFile() {
+        return !!(this.flags & FSCapabilityFlags.Read);
+    }
+    get writeFile() {
+        return !!(this.flags & FSCapabilityFlags.Write);
+    }
+    get readDirectory() {
+        return !!(this.flags & FSCapabilityFlags.ReadDir);
+    }
+    get writeDirectory() {
+        return !!(this.flags & FSCapabilityFlags.WriteDir);
+    }
+    get stat() {
+        return !!(this.flags & FSCapabilityFlags.Stat);
+    }
+}
+export function fsCapabilities(flags) {
+    return new CFsCapabilities(flags);
+}
+class WrappedProviderFs {
+    fs;
+    hasProvider;
+    capabilities;
+    providerInfo;
+    _capabilities;
+    constructor(fs) {
+        this.fs = fs;
+        this.hasProvider = !!fs;
+        this.capabilities = fs?.capabilities || FSCapabilityFlags.None;
+        this._capabilities = fsCapabilities(this.capabilities);
+        this.providerInfo = fs?.providerInfo || { name: 'unknown' };
+    }
+    getCapabilities(url) {
+        if (this.fs?.getCapabilities)
+            return this.fs.getCapabilities(url);
+        return this._capabilities;
+    }
+    async stat(url) {
+        try {
+            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Stat, 'stat', urlOrReferenceToUrl(url));
+            return new CVfsStat(await this.fs.stat(url));
+        }
+        catch (e) {
+            throw wrapError(e);
+        }
+    }
+    async readFile(url) {
+        try {
+            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Read, 'readFile', urlOrReferenceToUrl(url));
+            return await this.fs.readFile(url);
+        }
+        catch (e) {
+            throw wrapError(e);
+        }
+    }
+    async readDirectory(url) {
+        try {
+            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.ReadDir, 'readDirectory', url);
+            return (await this.fs.readDirectory(url)).map((e) => new CVfsDirEntry(e));
+        }
+        catch (e) {
+            throw wrapError(e);
+        }
+    }
+    async writeFile(file) {
+        try {
+            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Write, 'writeFile', file.url);
+            return await this.fs.writeFile(file);
+        }
+        catch (e) {
+            throw wrapError(e);
+        }
+    }
+    static disposeOf(fs) {
+        fs instanceof WrappedProviderFs && fs.fs?.dispose();
+    }
+}
+function checkCapabilityOrThrow(fs, capabilities, flag, name, url) {
+    if (!(capabilities & flag)) {
+        throw new VFSErrorUnsupportedRequest(name, url);
+    }
+}
+class CFileType {
+    fileType;
+    constructor(fileType) {
+        this.fileType = fileType;
+    }
+    isFile() {
+        return this.fileType === FileType.File;
+    }
+    isDirectory() {
+        return this.fileType === FileType.Directory;
+    }
+    isUnknown() {
+        return !this.fileType;
+    }
+}
+class CVfsStat extends CFileType {
+    stat;
+    constructor(stat) {
+        super(stat.fileType || FileType.Unknown);
+        this.stat = stat;
+    }
+    get size() {
+        return this.stat.size;
+    }
+    get mtimeMs() {
+        return this.stat.mtimeMs;
+    }
+    get eTag() {
+        return this.stat.eTag;
+    }
+}
+class CVfsDirEntry extends CFileType {
+    entry;
+    _url;
+    constructor(entry) {
+        super(entry.fileType);
+        this.entry = entry;
+    }
+    get name() {
+        return this.entry.name;
+    }
+    get dir() {
+        return this.entry.dir;
+    }
+    get url() {
+        if (this._url)
+            return this._url;
+        this._url = new URL(this.entry.name, this.entry.dir);
+        return this._url;
+    }
+}
+//# sourceMappingURL=VirtualFS.js.map

package/dist/esm/common/CFileReference.d.ts

@@ -31,4 +31,5 @@ export declare class CFileReference implements FileReference {
  */
 export declare function toFileReference(file: UrlOrReference, encoding?: BufferEncoding, baseFilename?: string, gz?: boolean | undefined): FileReference;
 export declare function isFileReference(ref: UrlOrReference): ref is FileReference;
+export declare function renameFileReference(ref: FileReference, newUrl: URL): FileReference;
 //# sourceMappingURL=CFileReference.d.ts.map

package/dist/esm/common/CFileReference.js

@@ -51,4 +51,7 @@ export function toFileReference(file, encoding, baseFilename, gz) {
 export function isFileReference(ref) {
     return CFileReference.isCFileReference(ref) || (!(ref instanceof URL) && typeof ref !== 'string');
 }
+export function renameFileReference(ref, newUrl) {
+    return new CFileReference(newUrl, ref.encoding, ref.baseFilename, ref.gz);
+}
 //# sourceMappingURL=CFileReference.js.map

package/dist/esm/common/CFileResource.d.ts

@@ -1,6 +1,6 @@
 import type { BufferEncoding } from '../models/BufferEncoding.js';
-import type { FileReference, FileResource, FileResourceBase } from '../models/FileResource.js';
-export declare class CFileResource implements FileResource {
+import type { FileReference, FileResource, TextFileResource } from '../models/FileResource.js';
+export declare class CFileResource implements TextFileResource {
     readonly url: URL;
     readonly content: string | ArrayBufferView;
     readonly encoding: BufferEncoding | undefined;
@@ -18,8 +18,11 @@ export declare class CFileResource implements FileResource {
         gz: boolean;
     };
     static isCFileResource(obj: unknown): obj is CFileResource;
-    static from(fileResource: FileResourceBase): CFileResource;
+    static from(fileResource: FileResource): CFileResource;
     static from(fileReference: FileReference, content: string | ArrayBufferView): CFileResource;
-    static from(url: URL, content: string | ArrayBufferView, encoding?: BufferEncoding, baseFilename?: string | undefined, gz?: boolean): CFileResource;
+    static from(fileReference: FileReference | URL, content: string | ArrayBufferView): CFileResource;
+    static from(url: URL, content: string | ArrayBufferView, encoding?: BufferEncoding | undefined, baseFilename?: string | undefined, gz?: boolean): CFileResource;
 }
+export declare function fromFileResource(fileResource: FileResource): TextFileResource;
+export declare function renameFileResource(fileResource: FileResource, url: URL): FileResource;
 //# sourceMappingURL=CFileResource.d.ts.map

package/dist/esm/common/CFileResource.js

@@ -43,8 +43,13 @@ export class CFileResource {
         return obj instanceof CFileResource;
     }
     static from(urlOrFileResource, content, encoding, baseFilename, gz) {
-        if (CFileResource.isCFileResource(urlOrFileResource))
+        if (CFileResource.isCFileResource(urlOrFileResource)) {
+            if (content) {
+                const { url, encoding, baseFilename, gz } = urlOrFileResource;
+                return new CFileResource(url, content, encoding, baseFilename, gz);
+            }
             return urlOrFileResource;
+        }
         if (urlOrFileResource instanceof URL) {
             assert(content !== undefined);
             return new CFileResource(urlOrFileResource, content, encoding, baseFilename, gz);
@@ -58,4 +63,10 @@ export class CFileResource {
         return new CFileResource(fileResource.url, fileResource.content, fileResource.encoding, fileResource.baseFilename, fileResource.gz);
     }
 }
+export function fromFileResource(fileResource) {
+    return CFileResource.from(fileResource);
+}
+export function renameFileResource(fileResource, url) {
+    return CFileResource.from(url, fileResource.content, fileResource.encoding, fileResource.baseFilename, fileResource.gz);
+}
 //# sourceMappingURL=CFileResource.js.map

package/dist/esm/common/index.d.ts

@@ -1,3 +1,4 @@
-export { CFileReference } from './CFileReference.js';
-export { CFileResource } from './CFileResource.js';
+export { CFileReference, renameFileReference } from './CFileReference.js';
+export { CFileResource, fromFileResource as createTextFileResource, renameFileResource } from './CFileResource.js';
+export { urlOrReferenceToUrl } from './urlOrReferenceToUrl.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/common/index.js

@@ -1,3 +1,4 @@
-export { CFileReference } from './CFileReference.js';
-export { CFileResource } from './CFileResource.js';
+export { CFileReference, renameFileReference } from './CFileReference.js';
+export { CFileResource, fromFileResource as createTextFileResource, renameFileResource } from './CFileResource.js';
+export { urlOrReferenceToUrl } from './urlOrReferenceToUrl.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/common/urlOrReferenceToUrl.d.ts

@@ -0,0 +1,5 @@
+import type { FileReference } from '../models/index.js';
+type UrlOrReference = URL | FileReference;
+export declare function urlOrReferenceToUrl(urlOrReference: UrlOrReference): URL;
+export {};
+//# sourceMappingURL=urlOrReferenceToUrl.d.ts.map

package/dist/esm/common/urlOrReferenceToUrl.js

@@ -0,0 +1,4 @@
+export function urlOrReferenceToUrl(urlOrReference) {
+    return urlOrReference instanceof URL ? urlOrReference : urlOrReference.url;
+}
+//# sourceMappingURL=urlOrReferenceToUrl.js.map

package/dist/esm/handlers/node/file.js

@@ -8,11 +8,13 @@ import { encodeString, isGZipped } from '../../common/encode-decode.js';
 import { CFileResource } from '../../common/index.js';
 import { assert } from '../../errors/assert.js';
 import { toError } from '../../errors/index.js';
+import { FileType } from '../../models/index.js';
 import { decodeDataUrl, guessMimeType, toDataUrl } from '../../node/dataUrl.js';
 import { fetchURL } from '../../node/file/fetch.js';
 import { getStatHttp } from '../../node/file/stat.js';
 import { urlBasename } from '../../node/file/url.js';
 import { RequestFsReadFile, RequestFsReadFileSync, RequestFsStat, RequestFsStatSync, RequestFsWriteFile, RequestZlibInflate, } from '../../requests/index.js';
+import { RequestFsReadDirectory } from '../../requests/RequestFsReadDirectory.js';
 const isGzFileRegExp = /\.gz($|[?#])/;
 function isGzFile(url) {
     return isGzFileRegExp.test(typeof url === 'string' ? url : url.pathname);
@@ -34,6 +36,14 @@ const handleRequestFsReadFile = RequestFsReadFile.createRequestHandler(({ params
  * Handle Binary File Sync Reads
  */
 const handleRequestFsReadFileSync = RequestFsReadFileSync.createRequestHandler(({ params }) => createResponse(CFileResource.from({ ...params, content: readFileSync(fileURLToPath(params.url)) })), undefined, 'Node: Sync Read Binary File.');
+/**
+ * Handle Binary File Reads
+ */
+const handleRequestFsReadDirectory = RequestFsReadDirectory.createRequestHandler(({ params }) => {
+    return createResponse(fs
+        .readdir(fileURLToPath(params.url), { withFileTypes: true })
+        .then((entries) => direntToDirEntries(params.url, entries)));
+}, undefined, 'Node: Read Directory.');
 /**
  * Handle deflating gzip data
  */
@@ -74,7 +84,17 @@ const handleRequestFsReadFileData = RequestFsReadFile.createRequestHandler((req,
 /**
  * Handle fs:stat
  */
-const handleRequestFsStat = RequestFsStat.createRequestHandler(({ params }) => createResponse(fs.stat(fileURLToPath(params.url))), undefined, 'Node: fs.stat.');
+const handleRequestFsStat = RequestFsStat.createRequestHandler(({ params }) => createResponse(toPromiseStats(fs.stat(fileURLToPath(params.url)))), undefined, 'Node: fs.stat.');
+function toStats(stat) {
+    return {
+        size: stat.size,
+        mtimeMs: stat.mtimeMs,
+        fileType: toFileType(stat),
+    };
+}
+function toPromiseStats(pStat) {
+    return pStat.then(toStats);
+}
 /**
  * Handle fs:statSync
  */
@@ -158,6 +178,7 @@ export function registerHandlers(serviceBus) {
         handleRequestFsReadFileHttp,
         handleRequestFsReadFileData,
         handleRequestFsReadFileSyncData,
+        handleRequestFsReadDirectory,
         handleRequestZlibInflate,
         handleRequestFsStatSync,
         handleRequestFsStat,
@@ -173,4 +194,20 @@ function encodeContent(ref, content) {
     }
     return arrayBufferViewToBuffer(content);
 }
+function mapperDirentToDirEntry(dir) {
+    return (dirent) => direntToDirEntry(dir, dirent);
+}
+function direntToDirEntries(dir, dirent) {
+    return dirent.map(mapperDirentToDirEntry(dir));
+}
+function direntToDirEntry(dir, dirent) {
+    return {
+        name: dirent.name,
+        dir,
+        fileType: toFileType(dirent),
+    };
+}
+function toFileType(statLike) {
+    return statLike.isFile() ? FileType.File : statLike.isDirectory() ? FileType.Directory : FileType.Unknown;
+}
 //# sourceMappingURL=file.js.map

package/dist/esm/index.d.ts

@@ -1,9 +1,14 @@
 export { toArray as asyncIterableToArray } from './async/asyncIterable.js';
 export * from './common/index.js';
+export { createTextFileResource } from './common/index.js';
 export type { CSpellIO } from './CSpellIO.js';
 export { CSpellIONode, getDefaultCSpellIO } from './CSpellIONode.js';
 export { getStat, getStatSync, readFileText, readFileTextSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from './file/index.js';
 export type { BufferEncoding, TextEncoding } from './models/BufferEncoding.js';
 export type { Stats } from './models/Stats.js';
 export { encodeDataUrl, toDataUrl } from './node/dataUrl.js';
+export { isFileURL, isUrlLike, toFileURL, toURL, urlBasename, urlDirname } from './node/file/url.js';
+export type { VFileSystem as VFileSystem, VFileSystemProvider, VfsDirEntry, VfsStat, VirtualFS } from './VirtualFS.js';
+export { createVirtualFS, FSCapabilityFlags, getDefaultVirtualFs } from './VirtualFS.js';
+export { createRedirectProvider } from './VirtualFS/redirectProvider.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -1,6 +1,10 @@
 export { toArray as asyncIterableToArray } from './async/asyncIterable.js';
 export * from './common/index.js';
+export { createTextFileResource } from './common/index.js';
 export { CSpellIONode, getDefaultCSpellIO } from './CSpellIONode.js';
 export { getStat, getStatSync, readFileText, readFileTextSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from './file/index.js';
 export { encodeDataUrl, toDataUrl } from './node/dataUrl.js';
+export { isFileURL, isUrlLike, toFileURL, toURL, urlBasename, urlDirname } from './node/file/url.js';
+export { createVirtualFS, FSCapabilityFlags, getDefaultVirtualFs } from './VirtualFS.js';
+export { createRedirectProvider } from './VirtualFS/redirectProvider.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/models/FileResource.d.ts

@@ -20,13 +20,13 @@ export interface FileReference {
      */
     readonly gz?: boolean | undefined;
 }
-export interface FileResourceBase extends FileReference {
+export interface FileResource extends FileReference {
     /**
      * The contents of the file
      */
     readonly content: string | ArrayBufferView;
 }
-export interface FileResource extends FileResourceBase {
+export interface TextFileResource extends FileResource {
     getText(): string;
 }
 export type UrlOrFilename = string | URL;

package/dist/esm/models/Stats.d.ts

@@ -14,5 +14,28 @@ export interface Stats {
      * Used by web requests to see if a resource has changed.
      */
     eTag?: string | undefined;
+    /**
+     * The file type.
+     */
+    fileType?: FileType | undefined;
+}
+export declare enum FileType {
+    /**
+     * The file type is unknown.
+     */
+    Unknown = 0,
+    /**
+     * A regular file.
+     */
+    File = 1,
+    /**
+     * A directory.
+     */
+    Directory = 2
+}
+export interface DirEntry {
+    name: string;
+    dir: URL;
+    fileType: FileType;
 }
 //# sourceMappingURL=Stats.d.ts.map

package/dist/esm/models/Stats.js

@@ -1,5 +1,16 @@
-/**
- * Subset of definition from the Node definition to avoid a dependency upon a specific version of Node
- */
-export {};
+export var FileType;
+(function (FileType) {
+    /**
+     * The file type is unknown.
+     */
+    FileType[FileType["Unknown"] = 0] = "Unknown";
+    /**
+     * A regular file.
+     */
+    FileType[FileType["File"] = 1] = "File";
+    /**
+     * A directory.
+     */
+    FileType[FileType["Directory"] = 2] = "Directory";
+})(FileType || (FileType = {}));
 //# sourceMappingURL=Stats.js.map

package/dist/esm/models/disposable.d.ts

@@ -0,0 +1,4 @@
+export interface Disposable {
+    dispose(): void;
+}
+//# sourceMappingURL=disposable.d.ts.map

package/dist/esm/models/disposable.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=disposable.js.map

package/dist/esm/models/index.d.ts

@@ -1,2 +1,6 @@
-export type { Stats } from './Stats.js';
+export type { BufferEncoding, TextEncoding } from './BufferEncoding.js';
+export type { Disposable } from './disposable.js';
+export type { FileReference, FileResource, TextFileResource, UrlOrReference } from './FileResource.js';
+export type { DirEntry, Stats } from './Stats.js';
+export { FileType } from './Stats.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/models/index.js

@@ -1,2 +1,2 @@
-export {};
+export { FileType } from './Stats.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/node/file/fetch.js

@@ -4,6 +4,9 @@ export async function fetchHead(request) {
     const url = toURL(request);
     try {
         const r = await fetch(url, { method: 'HEAD' });
+        if (!r.ok) {
+            throw FetchUrlError.create(url, r.status);
+        }
         return r.headers;
     }
     catch (e) {

package/dist/esm/node/file/url.d.ts

@@ -26,6 +26,7 @@ export declare function toURL(filenameOrUrl: string | URL, relativeTo?: string |
 export declare function urlBasename(url: string | URL): string;
 /**
  * Try to determine the parent directory URL of the uri.
+ * If it is not a hierarchical URL, then it will return the URL.
  * @param url - url to extract the dirname from.
  * @returns a URL
  */
@@ -36,4 +37,5 @@ export declare function urlDirname(url: string | URL): URL;
  * @returns
  */
 export declare function basename(path: string): string;
+export declare function normalizePathForUrl(filePath: string): string;
 //# sourceMappingURL=url.d.ts.map