dirvi-lib 0.3.0 → 0.5.0

package/dist/domain/navigation-node.d.ts

@@ -1,43 +0,0 @@
-import { UnixEntry, UnixEntryName, UnixEntryPath } from './unix-entry.js';
-import { UnixPath } from './unix-path.js';
-import { FoldNode } from './fold-node.js';
-import { Cursor } from './cursor.js';
-export type NavigationEntry = {
-    kind: 'file';
-    name: UnixEntryName;
-} | {
-    kind: 'symlink';
-    name: UnixEntryName;
-    target: UnixPath;
-} | {
-    /**
-     * Undefined node means the directory has not been loaded.
-     */
-    kind: 'directory';
-    name: UnixEntryName;
-    node?: NavigationNode;
-};
-/**
- * A directory as navigated: list of visible entries and folded entries.
- */
-export type NavigationNode = {
-    /**
-     * Currently visible entries.
-     */
-    entries: NavigationEntry[];
-    /**
-     * Currently loaded entries hidden by this directory's fold.
-     */
-    foldedEntries: NavigationEntry[];
-};
-export declare const NavigationNode: {
-    from(entries: UnixEntry[] | undefined, foldNode: FoldNode | undefined): NavigationNode;
-    getNodeAtPath(navigation: NavigationNode, path: UnixEntryPath): NavigationNode | undefined;
-    getEntryAtPath(navigation: NavigationNode, path: UnixEntryPath): NavigationEntry | undefined;
-    nextCursor(rootNode: NavigationNode, cursor: Cursor): Cursor | undefined;
-    previousCursor(rootNode: NavigationNode, cursor: Cursor): Cursor | undefined;
-    cursorAfterFold(rootNode: NavigationNode, cursor: Cursor): Cursor | undefined;
-    parentCursor(navigation: NavigationNode, cursor: Cursor): Cursor | undefined;
-    visibleFilesPaths(navigation: NavigationNode, parentPath?: UnixEntryPath): UnixEntryPath[];
-};
-//# sourceMappingURL=navigation-node.d.ts.map

package/dist/domain/navigation-node.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"navigation-node.d.ts","sourceRoot":"","sources":["../../src/domain/navigation-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,MAAM,eAAe,GACvB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE;;OAEG;IACH,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,CAAC,EAAE,cAAc,CAAC;CACvB,CAAC;AAEN;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG;IAC3B;;OAEG;IACH,OAAO,EAAE,eAAe,EAAE,CAAC;IAE3B;;OAEG;IACH,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,cAAc;kBAEd,SAAS,EAAE,GAAG,SAAS,YACtB,QAAQ,GAAG,SAAS,GAC7B,cAAc;8BA4DH,cAAc,QACpB,aAAa,GAClB,cAAc,GAAG,SAAS;+BAyBf,cAAc,QACpB,aAAa,GAClB,eAAe,GAAG,SAAS;yBA0BT,cAAc,UAAU,MAAM,GAAG,MAAM,GAAG,SAAS;6BAc/C,cAAc,UAAU,MAAM,GAAG,MAAM,GAAG,SAAS;8BAehE,cAAc,UAChB,MAAM,GACb,MAAM,GAAG,SAAS;6BAsCI,cAAc,UAAU,MAAM,GAAG,MAAM,GAAG,SAAS;kCA6B9D,cAAc,eACd,aAAa,GACxB,aAAa,EAAE;CA2BnB,CAAC"}

package/dist/domain/navigation-node.js

@@ -1,198 +0,0 @@
-import { UnixEntryPath } from './unix-entry.js';
-import { Cursor } from './cursor.js';
-export const NavigationNode = {
-    from(entries, foldNode) {
-        if (entries === undefined) {
-            return {
-                entries: [],
-                foldedEntries: [],
-            };
-        }
-        const foldedNames = new Set(foldNode?.folds ?? []);
-        const visibleEntries = [];
-        const foldedEntries = [];
-        for (const entry of entries) {
-            let navigationEntry;
-            switch (entry.kind) {
-                case 'file':
-                    navigationEntry = {
-                        kind: 'file',
-                        name: entry.name,
-                    };
-                    break;
-                case 'symlink':
-                    navigationEntry = {
-                        kind: 'symlink',
-                        name: entry.name,
-                        target: entry.target,
-                    };
-                    break;
-                case 'directory': {
-                    const childFoldNode = foldNode?.children[entry.name];
-                    navigationEntry = {
-                        kind: 'directory',
-                        name: entry.name,
-                        node: entry.entries === undefined
-                            ? undefined
-                            : NavigationNode.from(entry.entries, childFoldNode),
-                    };
-                    break;
-                }
-            }
-            if (foldedNames.has(entry.name)) {
-                foldedEntries.push(navigationEntry);
-            }
-            else {
-                visibleEntries.push(navigationEntry);
-            }
-        }
-        return {
-            entries: visibleEntries,
-            foldedEntries,
-        };
-    },
-    getNodeAtPath(navigation, path) {
-        const [currentName, ...remainingPath] = path;
-        // An empty path identifies the current node.
-        if (currentName === undefined) {
-            return navigation;
-        }
-        const entry = [...navigation.entries, ...navigation.foldedEntries].find((candidate) => candidate.name === currentName);
-        if (entry === undefined || entry.kind !== 'directory') {
-            return undefined;
-        }
-        // The directory has not been loaded/opened.
-        if (entry.node === undefined) {
-            return undefined;
-        }
-        return NavigationNode.getNodeAtPath(entry.node, remainingPath);
-    },
-    getEntryAtPath(navigation, path) {
-        const [currentName, ...remainingPath] = path;
-        if (currentName === undefined) {
-            return undefined;
-        }
-        const entry = [...navigation.entries, ...navigation.foldedEntries].find((candidate) => candidate.name === currentName);
-        if (entry === undefined) {
-            return undefined;
-        }
-        if (remainingPath.length === 0) {
-            return entry;
-        }
-        if (entry.kind !== 'directory' || entry.node === undefined) {
-            return undefined;
-        }
-        return NavigationNode.getEntryAtPath(entry.node, remainingPath);
-    },
-    nextCursor(rootNode, cursor) {
-        const cursors = cursorsInNode(rootNode, []);
-        const currentIndex = cursors.findIndex((candidate) => Cursor.equal(candidate, cursor));
-        if (currentIndex === -1 || currentIndex === cursors.length - 1) {
-            return undefined;
-        }
-        return cursors[currentIndex + 1];
-    },
-    previousCursor(rootNode, cursor) {
-        const cursors = cursorsInNode(rootNode, []);
-        const currentIndex = cursors.findIndex((candidate) => Cursor.equal(candidate, cursor));
-        if (currentIndex <= 0) {
-            return undefined;
-        }
-        return cursors[currentIndex - 1];
-    },
-    cursorAfterFold(rootNode, cursor) {
-        if (cursor.kind === 'fold') {
-            return undefined;
-        }
-        const cursors = cursorsInNode(rootNode, []);
-        const currentIndex = cursors.findIndex((candidate) => Cursor.equal(candidate, cursor));
-        if (currentIndex === -1) {
-            return undefined;
-        }
-        const foldedPath = [...cursor.parentPath, cursor.entryName];
-        for (let index = currentIndex + 1; index < cursors.length; index += 1) {
-            const candidate = cursors[index];
-            if (candidate === undefined) {
-                continue;
-            }
-            if (cursorBelongsToSubtree(candidate, foldedPath)) {
-                continue;
-            }
-            return candidate;
-        }
-        // The fold row will be created at the end of this directory.
-        return {
-            kind: 'fold',
-            parentPath: cursor.parentPath,
-        };
-    },
-    parentCursor(navigation, cursor) {
-        const parentPath = cursor.parentPath;
-        // The cursor is already in the root directory.
-        if (parentPath.length === 0) {
-            return undefined;
-        }
-        const entryName = parentPath.at(-1);
-        if (entryName === undefined) {
-            return undefined;
-        }
-        const containingPath = parentPath.slice(0, -1);
-        const entry = NavigationNode.getEntryAtPath(navigation, parentPath);
-        if (entry === undefined || entry.kind !== 'directory') {
-            return undefined;
-        }
-        return {
-            kind: 'entry',
-            parentPath: containingPath,
-            entryName,
-        };
-    },
-    visibleFilesPaths(navigation, parentPath = []) {
-        const paths = [];
-        for (const entry of navigation.entries) {
-            const entryPath = [...parentPath, entry.name];
-            switch (entry.kind) {
-                case 'file':
-                    paths.push(entryPath);
-                    break;
-                case 'symlink':
-                    // Do not recurse through symlinks.
-                    break;
-                case 'directory':
-                    if (entry.node !== undefined) {
-                        paths.push(...NavigationNode.visibleFilesPaths(entry.node, entryPath));
-                    }
-                    break;
-            }
-        }
-        return paths;
-    },
-};
-function cursorsInNode(node, parentPath) {
-    const cursors = [];
-    for (const entry of node.entries) {
-        cursors.push({
-            kind: 'entry',
-            parentPath,
-            entryName: entry.name,
-        });
-        if (entry.kind !== 'directory' || entry.node === undefined) {
-            continue;
-        }
-        cursors.push(...cursorsInNode(entry.node, [...parentPath, entry.name]));
-    }
-    if (node.foldedEntries.length > 0) {
-        cursors.push({
-            kind: 'fold',
-            parentPath,
-        });
-    }
-    return cursors;
-}
-function cursorBelongsToSubtree(cursor, entryPath) {
-    if (cursor.kind === 'fold') {
-        return UnixEntryPath.isStrictPathPrefix(entryPath, cursor.parentPath);
-    }
-    const cursorPath = [...cursor.parentPath, cursor.entryName];
-    return UnixEntryPath.isStrictPathPrefix(entryPath, cursorPath);
-}

package/dist/domain/state.d.ts

@@ -1,12 +0,0 @@
-import { UnixEntry } from './unix-entry.js';
-import type { FoldNode } from './fold-node.js';
-import { Cursor } from './cursor.js';
-export type State = {
-    buffer: UnixEntry[];
-    folds: FoldNode;
-    cursor: Cursor;
-};
-export declare const View: {
-    getEntryAtCursor(view: State): UnixEntry | undefined;
-};
-//# sourceMappingURL=state.d.ts.map

package/dist/domain/state.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/domain/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,MAAM,KAAK,GAAG;IAClB,MAAM,EAAE,SAAS,EAAE,CAAC;IACpB,KAAK,EAAE,QAAQ,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,IAAI;2BACQ,KAAK,GAAG,SAAS,GAAG,SAAS;CAUrD,CAAA"}

package/dist/domain/state.js

@@ -1,12 +0,0 @@
-import { UnixEntry } from './unix-entry.js';
-import { Cursor } from './cursor.js';
-export const View = {
-    getEntryAtCursor(view) {
-        const path = Cursor.getPath(view.cursor);
-        // Nothing on folds
-        if (path === undefined) {
-            return undefined;
-        }
-        return UnixEntry.getEntryAtPath(view.buffer, path);
-    }
-};

package/dist/domain/unix-entry.d.ts

@@ -1,28 +0,0 @@
-import { z } from 'zod';
-import { UnixPath } from './unix-path.js';
-export declare const UnixEntryNameSchema: z.ZodString;
-export type UnixEntryName = z.output<typeof UnixEntryNameSchema>;
-export declare function entryNamesEqual(left: UnixEntryName[], right: UnixEntryName[]): boolean;
-export type UnixEntry = {
-    kind: 'file';
-    name: UnixEntryName;
-} | {
-    kind: 'symlink';
-    name: UnixEntryName;
-    target: UnixPath;
-} | {
-    kind: 'directory';
-    name: UnixEntryName;
-    entries?: UnixEntry[];
-};
-export declare const UnixEntry: {
-    getEntryAtPath(entries: UnixEntry[], path: UnixEntryPath): UnixEntry | undefined;
-    getEntriesAtPath(entries: UnixEntry[], path: UnixEntryPath): UnixEntry[] | undefined;
-    setEntriesAtPath(entries: UnixEntry[], path: UnixEntryPath, newEntries: UnixEntry[] | undefined): UnixEntry[];
-};
-export type UnixEntryPath = UnixEntryName[];
-export declare const UnixEntryPath: {
-    equal(left: UnixEntryPath, right: UnixEntryPath): boolean;
-    isStrictPathPrefix(prefix: UnixEntryPath, path: UnixEntryPath): boolean;
-};
-//# sourceMappingURL=unix-entry.d.ts.map

package/dist/domain/unix-entry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"unix-entry.d.ts","sourceRoot":"","sources":["../../src/domain/unix-entry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI1C,eAAO,MAAM,mBAAmB,aAQ5B,CAAC;AAEL,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEjE,wBAAgB,eAAe,CAC7B,IAAI,EAAE,aAAa,EAAE,EACrB,KAAK,EAAE,aAAa,EAAE,GACrB,OAAO,CAKT;AAED,MAAM,MAAM,SAAS,GACjB;IACE,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,aAAa,CAAC;CACrB,GACD;IACE,IAAI,EAAE,SAAS,CAAC;IAChB,IAAI,EAAE,aAAa,CAAC;IACpB,MAAM,EAAE,QAAQ,CAAC;CAClB,GACD;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,IAAI,EAAE,aAAa,CAAC;IAEpB,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;CACvB,CAAC;AAEN,eAAO,MAAM,SAAS;4BAGT,SAAS,EAAE,QACd,aAAa,GAClB,SAAS,GAAG,SAAS;8BA6Bb,SAAS,EAAE,QACd,aAAa,GAClB,SAAS,EAAE,GAAG,SAAS;8BAgBf,SAAS,EAAE,QACd,aAAa,cACP,SAAS,EAAE,GAAG,SAAS,GAClC,SAAS,EAAE;CAyDf,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,aAAa,EAAE,CAAC;AAE5C,eAAO,MAAM,aAAa;gBACZ,aAAa,SAAS,aAAa,GAAG,OAAO;+BAK/C,aAAa,QACf,aAAa,GAClB,OAAO;CAOX,CAAA"}

package/dist/domain/unix-entry.js

@@ -1,96 +0,0 @@
-import { z } from 'zod';
-// UNIX ENTRY
-export const UnixEntryNameSchema = z
-    .string()
-    .min(1)
-    .refine((value) => !value.includes('/'), {
-    message: "Entry name must not contain '/'",
-})
-    .refine((value) => value !== '.' && value !== '..', {
-    message: "Entry name cannot be '.' or '..'",
-});
-export function entryNamesEqual(left, right) {
-    return (left.length === right.length &&
-        left.every((name, index) => name === right[index]));
-}
-export const UnixEntry = {
-    // Query-Like
-    getEntryAtPath(entries, path) {
-        if (path.length === 0) {
-            return undefined;
-        }
-        let entry;
-        for (const [index, name] of path.entries()) {
-            entry = entries.find((candidate) => candidate.name === name);
-            if (entry === undefined) {
-                return undefined;
-            }
-            if (index === path.length - 1) {
-                return entry;
-            }
-            if (entry.kind !== 'directory' || entry.entries === undefined) {
-                return undefined;
-            }
-            entries = entry.entries;
-        }
-        return undefined;
-    },
-    getEntriesAtPath(entries, path) {
-        if (path.length === 0) {
-            return entries;
-        }
-        const entry = UnixEntry.getEntryAtPath(entries, path);
-        if (entry?.kind !== 'directory') {
-            return undefined;
-        }
-        return entry.entries;
-    },
-    // Command/Modifer-Like
-    setEntriesAtPath(entries, path, newEntries) {
-        const [currentName, ...remainingPath] = path;
-        if (currentName === undefined) {
-            throw new Error('Cannot update directory entries with an empty path');
-        }
-        let found = false;
-        const updatedEntries = entries.map((entry) => {
-            if (entry.name !== currentName) {
-                return entry;
-            }
-            found = true;
-            if (remainingPath.length === 0) {
-                if (entry.kind !== 'directory') {
-                    throw new Error(`Cannot update entries for non-directory entry "${entry.name}"`);
-                }
-                return {
-                    ...entry,
-                    entries: newEntries,
-                };
-            }
-            if (entry.kind !== 'directory') {
-                throw new Error(`Cannot descend through non-directory entry "${entry.name}"`);
-            }
-            if (entry.entries === undefined) {
-                throw new Error(`Cannot descend into unexpanded directory "${entry.name}"`);
-            }
-            return {
-                ...entry,
-                entries: UnixEntry.setEntriesAtPath(entry.entries, remainingPath, newEntries),
-            };
-        });
-        if (!found) {
-            throw new Error(`Directory path does not contain entry "${currentName}"`);
-        }
-        return updatedEntries;
-    },
-};
-export const UnixEntryPath = {
-    equal(left, right) {
-        return entryNamesEqual(left, right);
-    },
-    isStrictPathPrefix(prefix, path) {
-        if (path.length <= prefix.length) {
-            return false;
-        }
-        return prefix.every((name, index) => path[index] === name);
-    }
-};

package/dist/domain/view.d.ts

@@ -1,15 +0,0 @@
-import { UnixEntry } from './unix-entry.js';
-import type { FoldNode } from './fold-node.js';
-import { Cursor } from './cursor.js';
-export type DirectoryBuffer = {
-    entries: UnixEntry[];
-};
-export type View = {
-    buffer: DirectoryBuffer;
-    folds: FoldNode;
-    cursor: Cursor;
-};
-export declare const View: {
-    getEntryAtCursor(view: View): UnixEntry | undefined;
-};
-//# sourceMappingURL=view.d.ts.map

package/dist/domain/view.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"view.d.ts","sourceRoot":"","sources":["../../src/domain/view.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,EAAE,SAAS,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,IAAI,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,EAAE,QAAQ,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,eAAO,MAAM,IAAI;2BACQ,IAAI,GAAG,SAAS,GAAG,SAAS;CAUpD,CAAA"}

package/dist/domain/view.js

@@ -1,12 +0,0 @@
-import { UnixEntry } from './unix-entry.js';
-import { Cursor } from './cursor.js';
-export const View = {
-    getEntryAtCursor(view) {
-        const path = Cursor.getPath(view.cursor);
-        // Nothing on folds
-        if (path === undefined) {
-            return undefined;
-        }
-        return UnixEntry.getEntryAtPath(view.buffer.entries, path);
-    }
-};

package/dist/infrastructure/get-cwd.d.ts

@@ -1,3 +0,0 @@
-import type { UnixAbsolutePath } from '../domain/unix-path.js';
-export declare function getCwdAbsPath(): UnixAbsolutePath;
-//# sourceMappingURL=get-cwd.d.ts.map

package/dist/infrastructure/get-cwd.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-cwd.d.ts","sourceRoot":"","sources":["../../src/infrastructure/get-cwd.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAG/D,wBAAgB,aAAa,IAAI,gBAAgB,CAgBhD"}

package/dist/infrastructure/get-cwd.js

@@ -1,13 +0,0 @@
-import { UnixAbsolutePathSchema } from '../domain/unix-path.js';
-export function getCwdAbsPath() {
-    const currentWorkingDirectory = process.cwd();
-    const result = UnixAbsolutePathSchema.safeParse(currentWorkingDirectory);
-    if (!result.success) {
-        const details = result.error.issues
-            .map((issue) => issue.message)
-            .join('; ');
-        throw new Error(`Bad path for current working directory ` +
-            `"${currentWorkingDirectory}": ${details}`);
-    }
-    return result.data;
-}

package/dist/infrastructure/get-dir-lazy-entries.d.ts

@@ -1,4 +0,0 @@
-import type { UnixAbsolutePath } from '../domain/unix-path.js';
-import type { UnixEntry } from '../domain/unix-entry.js';
-export declare function getDirLazyEntries(address: UnixAbsolutePath): Promise<UnixEntry[]>;
-//# sourceMappingURL=get-dir-lazy-entries.d.ts.map

package/dist/infrastructure/get-dir-lazy-entries.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-dir-lazy-entries.d.ts","sourceRoot":"","sources":["../../src/infrastructure/get-dir-lazy-entries.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,gBAAgB,GACxB,OAAO,CAAC,SAAS,EAAE,CAAC,CAyCtB"}

package/dist/infrastructure/get-dir-lazy-entries.js

@@ -1,34 +0,0 @@
-import { readdir, readlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import { UnixPathSchema } from '../domain/unix-path.js';
-import { UnixEntryNameSchema } from '../domain/unix-entry.js';
-export async function getDirLazyEntries(address) {
-    const directoryEntries = await readdir(address, {
-        withFileTypes: true,
-    });
-    return Promise.all(directoryEntries.map(async (directoryEntry) => {
-        const name = UnixEntryNameSchema.parse(directoryEntry.name);
-        if (directoryEntry.isSymbolicLink()) {
-            const target = UnixPathSchema.parse(await readlink(join(address, directoryEntry.name)));
-            return {
-                kind: 'symlink',
-                name,
-                target,
-            };
-        }
-        if (directoryEntry.isDirectory()) {
-            return {
-                kind: 'directory',
-                name,
-                // Deliberately omitted: this directory has not been expanded.
-            };
-        }
-        if (directoryEntry.isFile()) {
-            return {
-                kind: 'file',
-                name,
-            };
-        }
-        throw new Error(`Unsupported filesystem entry "${join(address, directoryEntry.name)}"`);
-    }));
-}