dirvi-lib 0.3.0 → 0.4.0

package/dist/domain/intent.d.ts

@@ -0,0 +1,34 @@
+export type Intent = NormalModeIntent | CommandLineIntent;
+export type NormalModeIntent =
+  | {
+      intentType: 'normalRight';
+    }
+  | {
+      intentType: 'normalLeft';
+    }
+  | {
+      intentType: 'normalDown';
+    }
+  | {
+      intentType: 'normalUp';
+    }
+  | {
+      intentType: 'setNormalBuffer';
+      normalBuffer: string;
+    };
+export type CommandLineIntent =
+  | {
+      intentType: 'enterCommandLineMode';
+    }
+  | {
+      intentType: 'setCommandLine';
+      commandLine: string;
+    }
+  | {
+      intentType: 'executeCommandLine';
+      commandLine: string;
+    }
+  | {
+      intentType: 'exitCommandLineMode';
+    };
+//# sourceMappingURL=intent.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intent.d.ts","sourceRoot":"","sources":["../../src/domain/intent.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;AAE1D,MAAM,MAAM,gBAAgB,GACxB;IACE,UAAU,EAAE,aAAa,CAAC;CAC3B,GACD;IACE,UAAU,EAAE,YAAY,CAAC;CAC1B,GACD;IACE,UAAU,EAAE,YAAY,CAAC;CAC1B,GACD;IACE,UAAU,EAAE,UAAU,CAAC;CACxB,GACD;IACE,UAAU,EAAE,iBAAiB,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEN,MAAM,MAAM,iBAAiB,GACzB;IACE,UAAU,EAAE,sBAAsB,CAAC;CACpC,GACD;IACE,UAAU,EAAE,gBAAgB,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,UAAU,EAAE,oBAAoB,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;CACrB,GACD;IACE,UAAU,EAAE,qBAAqB,CAAC;CACnC,CAAC"}

package/dist/domain/intent.js

@@ -0,0 +1 @@
+export {};

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

@@ -2,42 +2,57 @@ 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;
-};
+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[];
+  /**
+   * 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[];
+  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
+//# sourceMappingURL=navigation-node.d.ts.map

package/dist/domain/navigation-node.js

@@ -1,198 +1,210 @@
 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;
-    },
+  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,
-        });
+  const cursors = [];
+  for (const entry of node.entries) {
+    cursors.push({
+      kind: 'entry',
+      parentPath,
+      entryName: entry.name,
+    });
+    if (entry.kind !== 'directory' || entry.node === undefined) {
+      continue;
     }
-    return cursors;
+    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);
+  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

@@ -2,11 +2,11 @@ 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;
+  buffer: UnixEntry[];
+  folds: FoldNode;
+  cursor: Cursor;
 };
 export declare const View: {
-    getEntryAtCursor(view: State): UnixEntry | undefined;
+  getEntryAtCursor(view: State): UnixEntry | undefined;
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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,CAAC"}

package/dist/domain/state.js

@@ -1,12 +1,12 @@
 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);
+  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

@@ -2,27 +2,43 @@ 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 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[];
+  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;
+  equal(left: UnixEntryPath, right: UnixEntryPath): boolean;
+  isStrictPathPrefix(prefix: UnixEntryPath, path: UnixEntryPath): boolean;
 };
-//# sourceMappingURL=unix-entry.d.ts.map
+//# sourceMappingURL=unix-entry.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"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;AAG1C,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;+BAI9B,aAAa,QAAQ,aAAa,GAAG,OAAO;CAOxE,CAAC"}