cspell-io 8.9.1 → 8.10.0

package/dist/esm/CVirtualFS.d.ts

@@ -0,0 +1,8 @@
+import type { CSpellIO } from './CSpellIO.js';
+import { VFileSystem, VFileSystemCore } from './VFileSystem.js';
+import { VirtualFS } from './VirtualFS.js';
+export declare function createVirtualFS(cspellIO?: CSpellIO): VirtualFS;
+export declare function getDefaultVirtualFs(): VirtualFS;
+export declare function getDefaultVFileSystemCore(): VFileSystemCore;
+export declare function getDefaultVFileSystem(): VFileSystem;
+//# sourceMappingURL=CVirtualFS.d.ts.map

package/dist/esm/CVirtualFS.js

@@ -0,0 +1,148 @@
+import { urlOrReferenceToUrl } from './common/index.js';
+import { getDefaultCSpellIO } from './CSpellIONode.js';
+import { debug } from './VirtualFS.js';
+import { CVFileSystem } from './VirtualFS/CVFileSystem.js';
+import { chopUrl, cspellIOToFsProvider, CVfsDirEntry, rPad, VFSErrorUnsupportedRequest, WrappedProviderFs, } from './VirtualFS/WrappedProviderFs.js';
+class CVirtualFS {
+    providers = new Set();
+    cachedFs = new Map();
+    revCacheFs = new Map();
+    fsc;
+    fs;
+    loggingEnabled = debug;
+    constructor() {
+        this.fsc = fsPassThroughCore((url) => this._getFS(url));
+        this.fs = new CVFileSystem(this.fsc);
+    }
+    enableLogging(value) {
+        this.loggingEnabled = value ?? true;
+    }
+    log = console.log;
+    logEvent = (event) => {
+        if (this.loggingEnabled) {
+            const id = event.traceID.toFixed(13).replaceAll(/\d{4}(?=\d)/g, '$&.');
+            const msg = event.message ? `\n\t\t${event.message}` : '';
+            const method = rPad(`${event.method}-${event.event}`, 16);
+            this.log(`${method} ID:${id} ts:${event.ts.toFixed(13)} ${chopUrl(event.url)}${msg}`);
+        }
+    };
+    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 new CVFileSystem(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.logEvent);
+        this.cachedFs.set(key, fs);
+        return fs;
+    }
+    reset() {
+        this.disposeOfCachedFs();
+    }
+    disposeOfCachedFs() {
+        for (const [key, fs] of [...this.cachedFs].reverse()) {
+            try {
+                WrappedProviderFs.disposeOf(fs);
+            }
+            catch {
+                // continue - we are cleaning up.
+            }
+            this.cachedFs.delete(key);
+        }
+        this.cachedFs.clear();
+        this.revCacheFs.clear();
+    }
+    dispose() {
+        this.disposeOfCachedFs();
+        const providers = [...this.providers].reverse();
+        for (const provider of providers) {
+            try {
+                provider.dispose?.();
+            }
+            catch {
+                // continue - we are cleaning up.
+            }
+        }
+    }
+}
+function fsPassThroughCore(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;
+}
+let defaultVirtualFs = undefined;
+export function getDefaultVirtualFs() {
+    if (!defaultVirtualFs) {
+        defaultVirtualFs = createVirtualFS();
+    }
+    return defaultVirtualFs;
+}
+export function getDefaultVFileSystemCore() {
+    return getDefaultVirtualFs().fsc;
+}
+export function getDefaultVFileSystem() {
+    return getDefaultVirtualFs().fs;
+}
+//# sourceMappingURL=CVirtualFS.js.map

package/dist/esm/VFileSystem.d.ts

@@ -0,0 +1,85 @@
+import type { BufferEncoding, DirEntry, FileReference, FileResource, Stats, TextFileResource } from './models/index.js';
+export type UrlOrReference = URL | FileReference;
+export declare enum FSCapabilityFlags {
+    None = 0,
+    Stat = 1,
+    Read = 2,
+    Write = 4,
+    ReadWrite = 6,
+    ReadDir = 8,
+    WriteDir = 16,
+    ReadWriteDir = 24
+}
+export interface FileSystemProviderInfo {
+    name: string;
+}
+export interface VFileSystemCore {
+    /**
+     * Read a file.
+     * @param url - URL to read
+     * @param encoding - optional encoding
+     * @returns A FileResource, the content will not be decoded. Use `.getText()` to get the decoded text.
+     */
+    readFile(url: UrlOrReference, encoding?: BufferEncoding): Promise<TextFileResource>;
+    /**
+     * Write a file
+     * @param file - the file to write
+     */
+    writeFile(file: FileResource): Promise<FileReference>;
+    /**
+     * Get the stats for a url.
+     * @param url - Url to fetch stats for.
+     */
+    stat(url: UrlOrReference): Promise<VfsStat>;
+    /**
+     * Read the directory entries for a url.
+     * The url should end with `/` to indicate a directory.
+     * @param url - the url to read the directory entries for.
+     */
+    readDirectory(url: URL): Promise<VfsDirEntry[]>;
+    /**
+     * Get the capabilities for a URL.
+     * The capabilities can be more restrictive than the general capabilities of the provider.
+     * @param url - the url to try
+     */
+    getCapabilities(url: URL): FSCapabilities;
+    /**
+     * Information about the provider.
+     * It is up to the provider to define what information is available.
+     */
+    providerInfo: FileSystemProviderInfo;
+    /**
+     * Indicates that a provider was found for the url.
+     */
+    hasProvider: boolean;
+}
+export interface VFileSystem extends VFileSystemCore {
+    findUp(name: string | string[] | VFindUpPredicate, from: URL, options?: VFindUpURLOptions): Promise<URL | undefined>;
+}
+export interface FSCapabilities {
+    readonly flags: FSCapabilityFlags;
+    readonly readFile: boolean;
+    readonly writeFile: boolean;
+    readonly readDirectory: boolean;
+    readonly writeDirectory: boolean;
+    readonly stat: boolean;
+}
+export interface VfsStat extends Stats {
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isUnknown(): boolean;
+    isSymbolicLink(): boolean;
+}
+export interface VfsDirEntry extends DirEntry {
+    isDirectory(): boolean;
+    isFile(): boolean;
+    isUnknown(): boolean;
+    isSymbolicLink(): boolean;
+}
+export type VFindEntryType = 'file' | 'directory' | '!file' | '!directory';
+export interface VFindUpURLOptions {
+    type?: VFindEntryType;
+    stopAt?: URL;
+}
+export type VFindUpPredicate = (dir: URL) => URL | undefined | Promise<URL | undefined>;
+//# sourceMappingURL=VFileSystem.d.ts.map

package/dist/esm/VFileSystem.js

@@ -0,0 +1,12 @@
+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 = {}));
+//# sourceMappingURL=VFileSystem.js.map

package/dist/esm/VirtualFS/CVFileSystem.d.ts

@@ -0,0 +1,14 @@
+import { VFileSystem, VFileSystemCore, VFindUpPredicate, VFindUpURLOptions } from '../VFileSystem.js';
+export declare class CVFileSystem implements VFileSystem {
+    #private;
+    readFile: VFileSystem['readFile'];
+    writeFile: VFileSystem['writeFile'];
+    stat: VFileSystem['stat'];
+    readDirectory: VFileSystem['readDirectory'];
+    getCapabilities: VFileSystem['getCapabilities'];
+    constructor(core: VFileSystemCore);
+    get providerInfo(): VFileSystem['providerInfo'];
+    get hasProvider(): VFileSystem['hasProvider'];
+    findUp(name: string | string[] | VFindUpPredicate, from: URL, options?: VFindUpURLOptions): Promise<URL | undefined>;
+}
+//# sourceMappingURL=CVFileSystem.d.ts.map

package/dist/esm/VirtualFS/CVFileSystem.js

@@ -0,0 +1,28 @@
+import { findUpFromUrl } from './findUpFromUrl.js';
+export class CVFileSystem {
+    #core;
+    readFile;
+    writeFile;
+    stat;
+    readDirectory;
+    getCapabilities;
+    constructor(core) {
+        this.#core = core;
+        this.readFile = this.#core.readFile.bind(this.#core);
+        this.writeFile = this.#core.writeFile.bind(this.#core);
+        this.stat = this.#core.stat.bind(this.#core);
+        this.readDirectory = this.#core.readDirectory.bind(this.#core);
+        this.getCapabilities = this.#core.getCapabilities.bind(this.#core);
+    }
+    get providerInfo() {
+        return this.#core.providerInfo;
+    }
+    get hasProvider() {
+        return this.#core.hasProvider;
+    }
+    findUp(name, from, options = {}) {
+        const opts = { ...options, fs: this.#core };
+        return findUpFromUrl(name, from, opts);
+    }
+}
+//# sourceMappingURL=CVFileSystem.js.map

package/dist/esm/VirtualFS/WrappedProviderFs.d.ts

@@ -0,0 +1,56 @@
+import type { CSpellIO } from '../CSpellIO.js';
+import type { BufferEncoding, DirEntry, FileReference, FileResource, TextFileResource } from '../models/index.js';
+import { FileType } from '../models/index.js';
+import type { LogEvent } from '../models/LogEvent.js';
+import { FileSystemProviderInfo, FSCapabilities, FSCapabilityFlags, UrlOrReference, VFileSystemCore, VfsDirEntry, VfsStat } from '../VFileSystem.js';
+import { VFileSystemProvider, VProviderFileSystem } from '../VirtualFS.js';
+export declare function cspellIOToFsProvider(cspellIO: CSpellIO): VFileSystemProvider;
+export declare class VFSError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export declare class VFSErrorUnsupportedRequest extends VFSError {
+    readonly request: string;
+    readonly parameters?: unknown | undefined;
+    readonly url?: string | undefined;
+    constructor(request: string, url?: URL | string, parameters?: unknown | undefined);
+}
+export declare function fsCapabilities(flags: FSCapabilityFlags): FSCapabilities;
+export declare class WrappedProviderFs implements VFileSystemCore {
+    private readonly fs;
+    readonly eventLogger: (event: LogEvent) => void;
+    readonly hasProvider: boolean;
+    readonly capabilities: FSCapabilityFlags;
+    readonly providerInfo: FileSystemProviderInfo;
+    private _capabilities;
+    constructor(fs: VProviderFileSystem | undefined, eventLogger: (event: LogEvent) => void);
+    private logEvent;
+    getCapabilities(url: URL): FSCapabilities;
+    stat(urlRef: UrlOrReference): Promise<VfsStat>;
+    readFile(urlRef: UrlOrReference, encoding?: BufferEncoding): Promise<TextFileResource>;
+    readDirectory(url: URL): Promise<VfsDirEntry[]>;
+    writeFile(file: FileResource): Promise<FileReference>;
+    static disposeOf<V extends VFileSystemCore>(fs: V): void;
+}
+declare class CFileType {
+    readonly fileType: FileType;
+    constructor(fileType: FileType);
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isUnknown(): boolean;
+    isSymbolicLink(): boolean;
+}
+export declare class CVfsDirEntry extends CFileType implements VfsDirEntry {
+    private entry;
+    private _url;
+    constructor(entry: DirEntry);
+    get name(): string;
+    get dir(): URL;
+    get url(): URL;
+    toJSON(): DirEntry;
+}
+export declare function chopUrl(url: URL | undefined): string;
+export declare function rPad(str: string, len: number, ch?: string): string;
+export {};
+//# sourceMappingURL=WrappedProviderFs.d.ts.map

package/dist/esm/VirtualFS/WrappedProviderFs.js

@@ -0,0 +1,250 @@
+import { createTextFileResource, urlOrReferenceToUrl } from '../common/index.js';
+import { FileType } from '../models/index.js';
+import { FSCapabilityFlags, } from '../VFileSystem.js';
+export 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;
+        },
+    };
+}
+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);
+}
+export class WrappedProviderFs {
+    fs;
+    eventLogger;
+    hasProvider;
+    capabilities;
+    providerInfo;
+    _capabilities;
+    constructor(fs, eventLogger) {
+        this.fs = fs;
+        this.eventLogger = eventLogger;
+        this.hasProvider = !!fs;
+        this.capabilities = fs?.capabilities || FSCapabilityFlags.None;
+        this._capabilities = fsCapabilities(this.capabilities);
+        this.providerInfo = fs?.providerInfo || { name: 'unknown' };
+    }
+    logEvent(method, event, traceID, url, message) {
+        this.eventLogger({ method, event, url, traceID, ts: performance.now(), message });
+    }
+    getCapabilities(url) {
+        if (this.fs?.getCapabilities)
+            return this.fs.getCapabilities(url);
+        return this._capabilities;
+    }
+    async stat(urlRef) {
+        const traceID = performance.now();
+        const url = urlOrReferenceToUrl(urlRef);
+        this.logEvent('stat', 'start', traceID, url);
+        try {
+            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Stat, 'stat', url);
+            return new CVfsStat(await this.fs.stat(urlRef));
+        }
+        catch (e) {
+            this.logEvent('stat', 'error', traceID, url, e instanceof Error ? e.message : '');
+            throw wrapError(e);
+        }
+        finally {
+            this.logEvent('stat', 'end', traceID, url);
+        }
+    }
+    async readFile(urlRef, encoding) {
+        const traceID = performance.now();
+        const url = urlOrReferenceToUrl(urlRef);
+        this.logEvent('readFile', 'start', traceID, url);
+        try {
+            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Read, 'readFile', url);
+            return createTextFileResource(await this.fs.readFile(urlRef), encoding);
+        }
+        catch (e) {
+            this.logEvent('readFile', 'error', traceID, url, e instanceof Error ? e.message : '');
+            throw wrapError(e);
+        }
+        finally {
+            this.logEvent('readFile', 'end', traceID, url);
+        }
+    }
+    async readDirectory(url) {
+        const traceID = performance.now();
+        this.logEvent('readDir', 'start', traceID, url);
+        try {
+            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.ReadDir, 'readDirectory', url);
+            return (await this.fs.readDirectory(url)).map((e) => new CVfsDirEntry(e));
+        }
+        catch (e) {
+            this.logEvent('readDir', 'error', traceID, url, e instanceof Error ? e.message : '');
+            throw wrapError(e);
+        }
+        finally {
+            this.logEvent('readDir', 'end', traceID, url);
+        }
+    }
+    async writeFile(file) {
+        const traceID = performance.now();
+        const url = file.url;
+        this.logEvent('writeFile', 'start', traceID, url);
+        try {
+            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Write, 'writeFile', file.url);
+            return await this.fs.writeFile(file);
+        }
+        catch (e) {
+            this.logEvent('writeFile', 'error', traceID, url, e instanceof Error ? e.message : '');
+            throw wrapError(e);
+        }
+        finally {
+            this.logEvent('writeFile', 'end', traceID, url);
+        }
+    }
+    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;
+    }
+    isSymbolicLink() {
+        return !!(this.fileType & FileType.SymbolicLink);
+    }
+}
+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;
+    }
+}
+export 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;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            dir: this.dir,
+            fileType: this.fileType,
+        };
+    }
+}
+export function chopUrl(url) {
+    if (!url)
+        return '';
+    const href = url.href;
+    const parts = href.split('/');
+    const n = parts.indexOf('node_modules');
+    if (n > 0) {
+        const tail = parts.slice(Math.max(parts.length - 3, n + 1));
+        return parts.slice(0, n + 1).join('/') + '/…/' + tail.join('/');
+    }
+    return href;
+}
+export function rPad(str, len, ch = ' ') {
+    return str.padEnd(len, ch);
+}
+//# sourceMappingURL=WrappedProviderFs.js.map

package/dist/esm/VirtualFS/findUpFromUrl.d.ts

@@ -0,0 +1,8 @@
+import type { VFileSystemCore, VFindUpURLOptions } from '../VFileSystem.js';
+export type FindUpFileSystem = Pick<VFileSystemCore, 'stat'>;
+export interface FindUpURLOptions extends VFindUpURLOptions {
+    fs: FindUpFileSystem;
+}
+export type FindUpPredicate = (dir: URL) => URL | undefined | Promise<URL | undefined>;
+export declare function findUpFromUrl(name: string | string[] | FindUpPredicate, from: URL, options: FindUpURLOptions): Promise<URL | undefined>;
+//# sourceMappingURL=findUpFromUrl.d.ts.map

package/dist/esm/VirtualFS/findUpFromUrl.js

@@ -0,0 +1,43 @@
+export async function findUpFromUrl(name, from, options) {
+    const { type: entryType = 'file', stopAt, fs } = options;
+    let dir = new URL('.', from);
+    const root = new URL('/', dir);
+    const predicate = makePredicate(fs, name, entryType);
+    const stopAtDir = stopAt || root;
+    let last = '';
+    while (dir.href !== last) {
+        const found = await predicate(dir);
+        if (found !== undefined)
+            return found;
+        last = dir.href;
+        if (dir.href === root.href || dir.href === stopAtDir.href)
+            break;
+        dir = new URL('..', dir);
+    }
+    return undefined;
+}
+function makePredicate(fs, name, entryType) {
+    if (typeof name === 'function')
+        return name;
+    const checkStat = entryType === 'file' || entryType === '!file' ? 'isFile' : 'isDirectory';
+    const checkValue = entryType.startsWith('!') ? false : true;
+    function checkName(dir, name) {
+        const f = new URL(name, dir);
+        return fs
+            .stat(f)
+            .then((stats) => ((stats.isUnknown() || stats[checkStat]() === checkValue) && f) || undefined)
+            .catch(() => undefined);
+    }
+    if (!Array.isArray(name))
+        return (dir) => checkName(dir, name);
+    return async (dir) => {
+        const pending = name.map((n) => checkName(dir, n));
+        for (const p of pending) {
+            const found = await p;
+            if (found)
+                return found;
+        }
+        return undefined;
+    };
+}
+//# sourceMappingURL=findUpFromUrl.js.map

package/dist/esm/VirtualFS/redirectProvider.d.ts

@@ -1,4 +1,5 @@
-import type { FSCapabilityFlags, VFileSystemProvider } from '../VirtualFS.js';
+import type { FSCapabilityFlags } from '../VFileSystem.js';
+import type { VFileSystemProvider } from '../VirtualFS.js';
 export interface RedirectOptions {
     /**
      * Option ts to mask the capabilities of the provider.

package/dist/esm/VirtualFS/redirectProvider.js

@@ -1,6 +1,6 @@
 import assert from 'node:assert';
 import { renameFileReference, renameFileResource, urlOrReferenceToUrl } from '../common/index.js';
-import { fsCapabilities, VFSErrorUnsupportedRequest } from '../VirtualFS.js';
+import { fsCapabilities, VFSErrorUnsupportedRequest } from './WrappedProviderFs.js';
 class RedirectProvider {
     name;
     publicRoot;

package/dist/esm/VirtualFS.d.ts

@@ -1,7 +1,7 @@
-import type { CSpellIO } from './CSpellIO.js';
-import type { BufferEncoding, DirEntry, Disposable, FileReference, FileResource, Stats, TextFileResource } from './models/index.js';
-type UrlOrReference = URL | FileReference;
-type NextProvider = (url: URL) => VProviderFileSystem | undefined;
+import type { DirEntry, Disposable, FileReference, FileResource, Stats } from './models/index.js';
+import type { FileSystemProviderInfo, FSCapabilities, FSCapabilityFlags, UrlOrReference, VFileSystem, VFileSystemCore } from './VFileSystem.js';
+export type NextProvider = (url: URL) => VProviderFileSystem | undefined;
+export declare const debug = false;
 export interface VirtualFS extends Disposable {
     registerFileSystemProvider(provider: VFileSystemProvider, ...providers: VFileSystemProvider[]): Disposable;
     /**
@@ -12,6 +12,10 @@ export interface VirtualFS extends Disposable {
      * The file system. All requests will first use getFileSystem to get the file system before making the request.
      */
     readonly fs: Required<VFileSystem>;
+    /**
+     * The file system core. All requests will first use getFileSystem to get the file system before making the request.
+     */
+    readonly fsc: Required<VFileSystemCore>;
     /**
      * Clear the cache of file systems.
      */
@@ -22,59 +26,6 @@ export interface VirtualFS extends Disposable {
     loggingEnabled: boolean;
     enableLogging(value?: boolean): void;
 }
-export declare enum FSCapabilityFlags {
-    None = 0,
-    Stat = 1,
-    Read = 2,
-    Write = 4,
-    ReadWrite = 6,
-    ReadDir = 8,
-    WriteDir = 16,
-    ReadWriteDir = 24
-}
-interface FileSystemProviderInfo {
-    name: string;
-}
-export interface VFileSystem {
-    /**
-     * Read a file.
-     * @param url - URL to read
-     * @param encoding - optional encoding
-     * @returns A FileResource, the content will not be decoded. Use `.getText()` to get the decoded text.
-     */
-    readFile(url: UrlOrReference, encoding?: BufferEncoding): Promise<TextFileResource>;
-    /**
-     * Write a file
-     * @param file - the file to write
-     */
-    writeFile(file: FileResource): Promise<FileReference>;
-    /**
-     * Get the stats for a url.
-     * @param url - Url to fetch stats for.
-     */
-    stat(url: UrlOrReference): Promise<VfsStat>;
-    /**
-     * Read the directory entries for a url.
-     * The url should end with `/` to indicate a directory.
-     * @param url - the url to read the directory entries for.
-     */
-    readDirectory(url: URL): Promise<VfsDirEntry[]>;
-    /**
-     * Get the capabilities for a URL.
-     * The capabilities can be more restrictive than the general capabilities of the provider.
-     * @param url - the url to try
-     */
-    getCapabilities(url: URL): FSCapabilities;
-    /**
-     * Information about the provider.
-     * It is up to the provider to define what information is available.
-     */
-    providerInfo: FileSystemProviderInfo;
-    /**
-     * Indicates that a provider was found for the url.
-     */
-    hasProvider: boolean;
-}
 export interface VProviderFileSystem extends Disposable {
     readFile(url: UrlOrReference): Promise<FileResource>;
     writeFile(file: FileResource): Promise<FileReference>;
@@ -108,39 +59,4 @@ export interface VFileSystemProvider extends Partial<Disposable> {
      */
     getFileSystem(url: URL, next: NextProvider): VProviderFileSystem | undefined;
 }
-export declare function createVirtualFS(cspellIO?: CSpellIO): VirtualFS;
-export declare function getDefaultVirtualFs(): VirtualFS;
-export declare class VFSError extends Error {
-    constructor(message: string, options?: {
-        cause?: unknown;
-    });
-}
-export declare class VFSErrorUnsupportedRequest extends VFSError {
-    readonly request: string;
-    readonly parameters?: unknown;
-    readonly url?: string | undefined;
-    constructor(request: string, url?: URL | string, parameters?: unknown);
-}
-export interface FSCapabilities {
-    readonly flags: FSCapabilityFlags;
-    readonly readFile: boolean;
-    readonly writeFile: boolean;
-    readonly readDirectory: boolean;
-    readonly writeDirectory: boolean;
-    readonly stat: boolean;
-}
-export declare function fsCapabilities(flags: FSCapabilityFlags): FSCapabilities;
-export interface VfsStat extends Stats {
-    isDirectory(): boolean;
-    isFile(): boolean;
-    isUnknown(): boolean;
-    isSymbolicLink(): boolean;
-}
-export interface VfsDirEntry extends DirEntry {
-    isDirectory(): boolean;
-    isFile(): boolean;
-    isUnknown(): boolean;
-    isSymbolicLink(): boolean;
-}
-export {};
 //# sourceMappingURL=VirtualFS.d.ts.map

package/dist/esm/VirtualFS.js

@@ -1,397 +1,2 @@
-import { createTextFileResource, urlOrReferenceToUrl } from './common/index.js';
-import { getDefaultCSpellIO } from './CSpellIONode.js';
-import { FileType } from './models/index.js';
-const debug = false;
-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;
-    loggingEnabled = debug;
-    constructor() {
-        this.fs = fsPassThrough((url) => this._getFS(url));
-    }
-    enableLogging(value) {
-        this.loggingEnabled = value ?? true;
-    }
-    log = console.log;
-    logEvent = (event) => {
-        if (this.loggingEnabled) {
-            const id = event.traceID.toFixed(13).replaceAll(/\d{4}(?=\d)/g, '$&.');
-            const msg = event.message ? `\n\t\t${event.message}` : '';
-            const method = rPad(`${event.method}-${event.event}`, 16);
-            this.log(`${method} ID:${id} ts:${event.ts.toFixed(13)} ${chopUrl(event.url)}${msg}`);
-        }
-    };
-    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.logEvent);
-        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 {
-                // 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 {
-                // 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;
-    eventLogger;
-    hasProvider;
-    capabilities;
-    providerInfo;
-    _capabilities;
-    constructor(fs, eventLogger) {
-        this.fs = fs;
-        this.eventLogger = eventLogger;
-        this.hasProvider = !!fs;
-        this.capabilities = fs?.capabilities || FSCapabilityFlags.None;
-        this._capabilities = fsCapabilities(this.capabilities);
-        this.providerInfo = fs?.providerInfo || { name: 'unknown' };
-    }
-    logEvent(method, event, traceID, url, message) {
-        this.eventLogger({ method, event, url, traceID, ts: performance.now(), message });
-    }
-    getCapabilities(url) {
-        if (this.fs?.getCapabilities)
-            return this.fs.getCapabilities(url);
-        return this._capabilities;
-    }
-    async stat(urlRef) {
-        const traceID = performance.now();
-        const url = urlOrReferenceToUrl(urlRef);
-        this.logEvent('stat', 'start', traceID, url);
-        try {
-            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Stat, 'stat', url);
-            return new CVfsStat(await this.fs.stat(urlRef));
-        }
-        catch (e) {
-            this.logEvent('stat', 'error', traceID, url, e instanceof Error ? e.message : '');
-            throw wrapError(e);
-        }
-        finally {
-            this.logEvent('stat', 'end', traceID, url);
-        }
-    }
-    async readFile(urlRef, encoding) {
-        const traceID = performance.now();
-        const url = urlOrReferenceToUrl(urlRef);
-        this.logEvent('readFile', 'start', traceID, url);
-        try {
-            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Read, 'readFile', url);
-            return createTextFileResource(await this.fs.readFile(urlRef), encoding);
-        }
-        catch (e) {
-            this.logEvent('readFile', 'error', traceID, url, e instanceof Error ? e.message : '');
-            throw wrapError(e);
-        }
-        finally {
-            this.logEvent('readFile', 'end', traceID, url);
-        }
-    }
-    async readDirectory(url) {
-        const traceID = performance.now();
-        this.logEvent('readDir', 'start', traceID, url);
-        try {
-            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.ReadDir, 'readDirectory', url);
-            return (await this.fs.readDirectory(url)).map((e) => new CVfsDirEntry(e));
-        }
-        catch (e) {
-            this.logEvent('readDir', 'error', traceID, url, e instanceof Error ? e.message : '');
-            throw wrapError(e);
-        }
-        finally {
-            this.logEvent('readDir', 'end', traceID, url);
-        }
-    }
-    async writeFile(file) {
-        const traceID = performance.now();
-        const url = file.url;
-        this.logEvent('writeFile', 'start', traceID, url);
-        try {
-            checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Write, 'writeFile', file.url);
-            return await this.fs.writeFile(file);
-        }
-        catch (e) {
-            this.logEvent('writeFile', 'error', traceID, url, e instanceof Error ? e.message : '');
-            throw wrapError(e);
-        }
-        finally {
-            this.logEvent('writeFile', 'end', traceID, url);
-        }
-    }
-    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;
-    }
-    isSymbolicLink() {
-        return !!(this.fileType & FileType.SymbolicLink);
-    }
-}
-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;
-    }
-    toJSON() {
-        return {
-            name: this.name,
-            dir: this.dir,
-            fileType: this.fileType,
-        };
-    }
-}
-function chopUrl(url) {
-    if (!url)
-        return '';
-    const href = url.href;
-    const parts = href.split('/');
-    const n = parts.indexOf('node_modules');
-    if (n > 0) {
-        const tail = parts.slice(Math.max(parts.length - 3, n + 1));
-        return parts.slice(0, n + 1).join('/') + '/…/' + tail.join('/');
-    }
-    return href;
-}
-function rPad(str, len, ch = ' ') {
-    return str + ch.repeat(Math.max(0, len - str.length));
-}
+export const debug = false;
 //# sourceMappingURL=VirtualFS.js.map

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

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 /**
  * Treat a ArrayBufferView as a Uint8Array.
  * The Uint8Array will share the same underlying ArrayBuffer.

package/dist/esm/index.d.ts

@@ -3,13 +3,15 @@ export * from './common/index.js';
 export { compareStats, createTextFileResource } from './common/index.js';
 export type { CSpellIO } from './CSpellIO.js';
 export { CSpellIONode, getDefaultCSpellIO } from './CSpellIONode.js';
+export { createVirtualFS, getDefaultVirtualFs } from './CVirtualFS.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 { FileType as VFileType } 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, VProviderFileSystem, } from './VirtualFS.js';
-export { createVirtualFS, FSCapabilityFlags, getDefaultVirtualFs } from './VirtualFS.js';
+export type { VFileSystem, VFileSystemCore, VFindEntryType, VFindUpPredicate, VFindUpURLOptions, VfsDirEntry, VfsStat, } from './VFileSystem.js';
+export { FSCapabilityFlags } from './VFileSystem.js';
+export type { VFileSystemProvider, VirtualFS, VProviderFileSystem } from './VirtualFS.js';
 export { createRedirectProvider } from './VirtualFS/redirectProvider.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.js

@@ -2,10 +2,11 @@ export { toArray as asyncIterableToArray } from './async/asyncIterable.js';
 export * from './common/index.js';
 export { compareStats, createTextFileResource } from './common/index.js';
 export { CSpellIONode, getDefaultCSpellIO } from './CSpellIONode.js';
+export { createVirtualFS, getDefaultVirtualFs } from './CVirtualFS.js';
 export { getStat, getStatSync, readFileText, readFileTextSync, writeToFile, writeToFileIterable, writeToFileIterableP, } from './file/index.js';
 export { FileType as VFileType } from './models/Stats.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 { FSCapabilityFlags } from './VFileSystem.js';
 export { createRedirectProvider } from './VirtualFS/redirectProvider.js';
 //# sourceMappingURL=index.js.map

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

@@ -0,0 +1,24 @@
+export type EventMethods = 'stat' | 'readFile' | 'writeFile' | 'readDir';
+export type LogEvents = 'start' | 'end' | 'error' | 'other';
+export interface LogEvent {
+    /**
+     * The request method
+     */
+    method: EventMethods;
+    event: LogEvents;
+    message?: string | undefined;
+    /**
+     * The trace id can be used to link request and response events.
+     * The trace id is unique for a given request.
+     */
+    traceID: number;
+    /**
+     * The request url
+     */
+    url?: URL | undefined;
+    /**
+     * The time in milliseconds, see `performance.now()`
+     */
+    ts: number;
+}
+//# sourceMappingURL=LogEvent.d.ts.map

package/dist/esm/models/LogEvent.js

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

package/dist/esm/node/dataUrl.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 /**
  * Generates a string of the following format:
  *

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

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 export declare class FetchUrlError extends Error implements NodeJS.ErrnoException {
     readonly code: string | undefined;
     readonly status: number | undefined;

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

@@ -1,4 +1,3 @@
-/// <reference types="node" resolution-mode="require"/>
 export declare function fetchHead(request: string | URL): Promise<Headers>;
 export declare function fetchURL(url: URL): Promise<Buffer>;
 //# sourceMappingURL=fetch.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-io",
-  "version": "8.9.1",
+  "version": "8.10.0",
   "description": "A library of useful I/O functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -49,11 +49,11 @@
   },
   "devDependencies": {
     "lorem-ipsum": "^2.0.8",
-    "typescript": "^5.4.5"
+    "typescript": "^5.5.3"
   },
   "dependencies": {
-    "@cspell/cspell-service-bus": "8.9.1",
-    "@cspell/url": "8.9.1"
+    "@cspell/cspell-service-bus": "8.10.0",
+    "@cspell/url": "8.10.0"
   },
-  "gitHead": "f532c77cca4bfae380293c586f02f377354c850b"
+  "gitHead": "a5dde6ae7e2ac86ac956220d4b8c39a0e58e1bc6"
 }